home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume9 / xterm / part04 < prev    next >
Encoding:
Internet Message Format  |  1987-04-20  |  60.4 KB

  1. Subject:  v09i057:  Terminal emulator for X window system, Part04/07
  2. Newsgroups: mod.sources
  3. Approved: rs@mirror.TMC.COM
  4.  
  5. Submitted by: edmoy%opal.Berkeley.EDU@berkeley.edu
  6. Mod.sources: Volume 9, Issue 57
  7. Archive-name: xterm6.6b/Part04
  8.  
  9. #! /bin/sh
  10. # This is a shell archive, meaning:
  11. # 1. Remove everything above the #! /bin/sh line.
  12. # 2. Save the resulting text in a file.
  13. # 3. Execute the file with /bin/sh (not csh) to create the files:
  14. #    charproc.c data.c
  15. if test -f charproc.c
  16. then
  17.     echo shar: will not overwrite existing file "'charproc.c'"
  18. else
  19. echo 'x - charproc.c'
  20. cat << \RAZZLE!DAZZLE > charproc.c
  21. /*
  22.  *    $Source: /u1/X/xterm/RCS/charproc.c,v $
  23.  *    $Header: charproc.c,v 10.102 86/12/02 11:37:25 swick Exp $
  24.  */
  25.  
  26. #include <X/mit-copyright.h>
  27.  
  28. /* Copyright (c) 1985 Massachusetts Institute of Technology        */
  29. /* Copyright (c) 1985    Digital Equipment Corporation            */
  30.  
  31. /* charproc.c */
  32.  
  33. #include <stdio.h>
  34. #include <sgtty.h>
  35. #include <ctype.h>
  36. #include <errno.h>
  37. #include <setjmp.h>
  38. #include <sys/ioctl.h>
  39. #include <sys/time.h>
  40. #include <X/Xlib.h>
  41. #include "scrollbar.h"
  42. #include "ptyx.h"
  43. #include "VTparse.h"
  44. #include "data.h"
  45. #include "error.h"
  46. #ifdef MODEMENU
  47. #include "menu.h"
  48. #endif MODEMENU
  49.  
  50. #define    DEFAULT        -1
  51. #define    TEXT_BUF_SIZE    256
  52.  
  53. #define    input()        (bcnt-- > 0 ? *bptr++ : in_put())
  54.  
  55. #ifndef lint
  56. static char sccs_id[] = "@(#)charproc.c\tX10/6.6B\t1/9/87";
  57. #endif lint
  58.  
  59. static long arg;
  60. static int ch;
  61. static int nparam;
  62. static ANSI reply;
  63. static int param[NPARAM];
  64.  
  65. static unsigned long ctotal;
  66. static unsigned long ntotal;
  67. static jmp_buf vtjmpbuf;
  68.  
  69. extern int groundtable[];
  70. extern int csitable[];
  71. extern int dectable[];
  72. extern int eigtable[];
  73. extern int esctable[];
  74. extern int iestable[];
  75. extern int igntable[];
  76. extern int scrtable[];
  77. extern int scstable[];
  78.  
  79. VTparse()
  80. {
  81.     register Screen *screen = &term.screen;
  82.     register int *parsestate = groundtable;
  83.     register int c;
  84.     register char *cp;
  85.     register int row, col, top, bot, scstype;
  86.     WindowInfo wininfo;
  87.     extern int bitset(), bitclr(), finput();
  88.  
  89.     if(setjmp(vtjmpbuf))
  90.         parsestate = groundtable;
  91.     for( ; ; )
  92.         switch(parsestate[c = input()]) {
  93.          case CASE_GROUND_STATE:
  94.             /* exit ignore mode */
  95.             parsestate = groundtable;
  96.             break;
  97.  
  98.          case CASE_IGNORE_STATE:
  99.             /* Ies: ignore anything else */
  100.             parsestate = igntable;
  101.             break;
  102.  
  103.          case CASE_IGNORE_ESC:
  104.             /* Ign: escape */
  105.             parsestate = iestable;
  106.             break;
  107.  
  108.          case CASE_IGNORE:
  109.             /* Ignore character */
  110.             break;
  111.  
  112.          case CASE_BELL:
  113.             /* bell */
  114.             Bell();
  115.             break;
  116.  
  117.          case CASE_BS:
  118.             /* backspace */
  119.             CursorBack(screen, 1);
  120.             break;
  121.  
  122.          case CASE_CR:
  123.             /* carriage return */
  124.             CarriageReturn(screen);
  125.             break;
  126.  
  127.          case CASE_ESC:
  128.             /* escape */
  129.             parsestate = esctable;
  130.             break;
  131.  
  132.          case CASE_VMOT:
  133.             /*
  134.              * form feed, line feed, vertical tab, but not in
  135.              * status line
  136.              */
  137.             if(!screen->instatus)
  138.                 Index(screen, 1);
  139.             if (term.flags & LINEFEED)
  140.                 CarriageReturn(screen);
  141.             if(screen->display->qlen > 0 ||
  142.              (ioctl(screen->display->fd, FIONREAD, &arg), arg) > 0)
  143.                 xevents();
  144.             break;
  145.  
  146.          case CASE_TAB:
  147.             /* tab */
  148.             screen->cur_col = TabNext(term.tabs, screen->cur_col);
  149.             if (screen->cur_col > screen->max_col)
  150.                 screen->cur_col = screen->max_col;
  151.             break;
  152.  
  153.          case CASE_SI:
  154.             screen->curgl = 0;
  155.             break;
  156.  
  157.          case CASE_SO:
  158.             screen->curgl = 1;
  159.             break;
  160.  
  161.          case CASE_SCR_STATE:
  162.             /* enter scr state */
  163.             parsestate = scrtable;
  164.             break;
  165.  
  166.          case CASE_SCS0_STATE:
  167.             /* enter scs state 0 */
  168.             scstype = 0;
  169.             parsestate = scstable;
  170.             break;
  171.  
  172.          case CASE_SCS1_STATE:
  173.             /* enter scs state 1 */
  174.             scstype = 1;
  175.             parsestate = scstable;
  176.             break;
  177.  
  178.          case CASE_SCS2_STATE:
  179.             /* enter scs state 2 */
  180.             scstype = 2;
  181.             parsestate = scstable;
  182.             break;
  183.  
  184.          case CASE_SCS3_STATE:
  185.             /* enter scs state 3 */
  186.             scstype = 3;
  187.             parsestate = scstable;
  188.             break;
  189.  
  190.          case CASE_ESC_IGNORE:
  191.             /* unknown escape sequence */
  192.             parsestate = eigtable;
  193.             break;
  194.  
  195.          case CASE_ESC_DIGIT:
  196.             /* digit in csi or dec mode */
  197.             if((row = param[nparam - 1]) == DEFAULT)
  198.                 row = 0;
  199.             param[nparam - 1] = 10 * row + (c - '0');
  200.             break;
  201.  
  202.          case CASE_ESC_SEMI:
  203.             /* semicolon in csi or dec mode */
  204.             param[nparam++] = DEFAULT;
  205.             break;
  206.  
  207.          case CASE_DEC_STATE:
  208.             /* enter dec mode */
  209.             parsestate = dectable;
  210.             break;
  211.  
  212.          case CASE_ICH:
  213.             /* ICH */
  214.             if((c = param[0]) < 1)
  215.                 c = 1;
  216.             InsertChar(screen, c);
  217.             parsestate = groundtable;
  218.             break;
  219.  
  220.          case CASE_CUU:
  221.             /* CUU */
  222.             /* only if not in status line */
  223.             if(!screen->instatus) {
  224.                 if((c = param[0]) < 1)
  225.                     c = 1;
  226.                 CursorUp(screen, c);
  227.             }
  228.             parsestate = groundtable;
  229.             break;
  230.  
  231.          case CASE_CUD:
  232.             /* CUD */
  233.             /* only if not in status line */
  234.             if(!screen->instatus) {
  235.                 if((c = param[0]) < 1)
  236.                     c = 1;
  237.                 CursorDown(screen, c);
  238.             }
  239.             parsestate = groundtable;
  240.             break;
  241.  
  242.          case CASE_CUF:
  243.             /* CUF */
  244.             if((c = param[0]) < 1)
  245.                 c = 1;
  246.             CursorForward(screen, c);
  247.             parsestate = groundtable;
  248.             break;
  249.  
  250.          case CASE_CUB:
  251.             /* CUB */
  252.             if((c = param[0]) < 1)
  253.                 c = 1;
  254.             CursorBack(screen, c);
  255.             parsestate = groundtable;
  256.             break;
  257.  
  258.          case CASE_CUP:
  259.             /* CUP | HVP */
  260.             /* only if not in status line */
  261.             if(!screen->instatus) {
  262.                 if((row = param[0]) < 1)
  263.                     row = 1;
  264.                 if(nparam < 2 || (col = param[1]) < 1)
  265.                     col = 1;
  266.                 CursorSet(screen, row-1, col-1, term.flags);
  267.             }
  268.             parsestate = groundtable;
  269.             break;
  270.  
  271.          case CASE_ED:
  272.             /* ED */
  273.             switch (param[0]) {
  274.              case DEFAULT:
  275.              case 0:
  276.                 if(screen->instatus)
  277.                     ClearRight(screen);
  278.                 else
  279.                     ClearBelow(screen);
  280.                 break;
  281.  
  282.              case 1:
  283.                 if(screen->instatus)
  284.                     ClearLeft(screen);
  285.                 else
  286.                     ClearAbove(screen);
  287.                 break;
  288.  
  289.              case 2:
  290.                 if(screen->instatus)
  291.                     ClearLine(screen);
  292.                 else
  293.                     ClearScreen(screen);
  294.                 break;
  295.             }
  296.             parsestate = groundtable;
  297.             break;
  298.  
  299.          case CASE_EL:
  300.             /* EL */
  301.             switch (param[0]) {
  302.              case DEFAULT:
  303.              case 0:
  304.                 ClearRight(screen);
  305.                 break;
  306.              case 1:
  307.                 ClearLeft(screen);
  308.                 break;
  309.              case 2:
  310.                 ClearLine(screen);
  311.                 break;
  312.             }
  313.             parsestate = groundtable;
  314.             break;
  315.  
  316.          case CASE_IL:
  317.             /* IL */
  318.             /* only if not in status line */
  319.             if(!screen->instatus) {
  320.                 if((c = param[0]) < 1)
  321.                     c = 1;
  322.                 InsertLine(screen, c);
  323.             }
  324.             parsestate = groundtable;
  325.             break;
  326.  
  327.          case CASE_DL:
  328.             /* DL */
  329.             /* only if not in status line */
  330.             if(!screen->instatus) {
  331.                 if((c = param[0]) < 1)
  332.                     c = 1;
  333.                 DeleteLine(screen, c);
  334.             }
  335.             parsestate = groundtable;
  336.             break;
  337.  
  338.          case CASE_DCH:
  339.             /* DCH */
  340.             if((c = param[0]) < 1)
  341.                 c = 1;
  342.             DeleteChar(screen, c);
  343.             parsestate = groundtable;
  344.             break;
  345.  
  346.          case CASE_DA1:
  347.             /* DA1 */
  348.             if (param[0] <= 0) {    /* less than means DEFAULT */
  349.                 reply.a_type   = CSI;
  350.                 reply.a_pintro = '?';
  351.                 reply.a_nparam = 2;
  352.                 reply.a_param[0] = 1;        /* VT102 */
  353.                 reply.a_param[1] = 2;        /* VT102 */
  354.                 reply.a_inters = 0;
  355.                 reply.a_final  = 'c';
  356.                 unparseseq(&reply, screen->respond);
  357.             }
  358.             parsestate = groundtable;
  359.             break;
  360.  
  361.          case CASE_TBC:
  362.             /* TBC */
  363.             if ((c = param[0]) <= 0) /* less than means default */
  364.                 TabClear(term.tabs, screen->cur_col);
  365.             else if (c == 3)
  366.                 TabZonk(term.tabs);
  367.             parsestate = groundtable;
  368.             break;
  369.  
  370.          case CASE_SET:
  371.             /* SET */
  372.             modes(&term, bitset);
  373.             parsestate = groundtable;
  374.             break;
  375.  
  376.          case CASE_RST:
  377.             /* RST */
  378.             modes(&term, bitclr);
  379.             parsestate = groundtable;
  380.             break;
  381.  
  382.          case CASE_SGR:
  383.             /* SGR */
  384.             for (c=0; c<nparam; ++c) {
  385.                 switch (param[c]) {
  386.                  case DEFAULT:
  387.                  case 0:
  388.                     term.flags &= ~(INVERSE|BOLD|UNDERLINE);
  389.                     break;
  390.                  case 1:
  391.                  case 5:    /* Blink, really.    */
  392.                     term.flags |= BOLD;
  393.                     break;
  394.                  case 4:    /* Underscore        */
  395.                     term.flags |= UNDERLINE;
  396.                     break;
  397.                  case 7:
  398.                     term.flags |= INVERSE;
  399.                 }
  400.             }
  401.             parsestate = groundtable;
  402.             break;
  403.  
  404.          case CASE_CPR:
  405.             /* CPR */
  406.             if ((c = param[0]) == 5) {
  407.                 reply.a_type = CSI;
  408.                 reply.a_pintro = 0;
  409.                 reply.a_nparam = 1;
  410.                 reply.a_param[0] = 0;
  411.                 reply.a_inters = 0;
  412.                 reply.a_final  = 'n';
  413.                 unparseseq(&reply, screen->respond);
  414.             } else if (c == 6) {
  415.                 reply.a_type = CSI;
  416.                 reply.a_pintro = 0;
  417.                 reply.a_nparam = 2;
  418.                 reply.a_param[0] = screen->cur_row+1;
  419.                 reply.a_param[1] = screen->cur_col+1;
  420.                 reply.a_inters = 0;
  421.                 reply.a_final  = 'R';
  422.                 unparseseq(&reply, screen->respond);
  423.             }
  424.             parsestate = groundtable;
  425.             break;
  426.  
  427.          case CASE_DECSTBM:
  428.             /* DECSTBM */
  429.             /* only if not in status line */
  430.             if(!screen->instatus) {
  431.                 if((top = param[0]) < 1)
  432.                     top = 1;
  433.                 if(nparam < 2 || (bot = param[1]) == DEFAULT
  434.                    || bot > screen->max_row + 1
  435.                    || bot == 0)
  436.                     bot = screen->max_row+1;
  437.                 if (bot > top) {
  438.                     if(screen->scroll_amt)
  439.                         FlushScroll(screen);
  440.                     screen->top_marg = top-1;
  441.                     screen->bot_marg = bot-1;
  442.                     CursorSet(screen, 0, 0, term.flags);
  443.                 }
  444.             }
  445.             parsestate = groundtable;
  446.             break;
  447.  
  448.          case CASE_SUN_EMU:
  449.             /* sub-set of sun tty emulation */
  450.             switch(param[0]) {
  451.              case 3:    /* move window */
  452.                 if(nparam == 3) {
  453.                     XMoveWindow(VWindow(screen), param[2],
  454.                      param[1]);
  455.                     XSync(FALSE);    /* synchronize */
  456.                     if(QLength() > 0)
  457.                         xevents();
  458.                 }
  459.                 break;
  460.              case 4:    /* resize window (pixels) */
  461.                 if(nparam == 3) {
  462.                     XChangeWindow (VWindow(screen), param[1],
  463.                      param[2]);
  464.                     XSync(FALSE);    /* synchronize */
  465.                     if(QLength() > 0)
  466.                         xevents();
  467.                 }
  468.                 break;
  469.              case 5:    /* raise window */
  470.                 XRaiseWindow(VWindow(screen));
  471.                 break;
  472.              case 6:    /* lower window */
  473.                 XLowerWindow(VWindow(screen));
  474.                 break;
  475.              case 7:    /* redisplay window */
  476.                 Redraw();
  477.                 break;
  478.              case 8:    /* resize window (rows and columns) */
  479.                 if(nparam == 3) {
  480.                     XChangeWindow (VWindow(screen),
  481.                      FontWidth(screen) * param[2] +
  482.                      2 * screen->border + screen->scrollbar,
  483.                      FontHeight(screen) * param[1] +
  484.                      screen->statusheight + Titlebar(screen)
  485.                      + 2 * screen->border);
  486.                     XSync(FALSE);    /* synchronize */
  487.                     if(QLength() > 0)
  488.                         xevents();
  489.                 }
  490.                 break;
  491.              case 13:    /* send window position */
  492.                 XQueryWindow(VWindow(screen), &wininfo);
  493.                 reply.a_type = CSI;
  494.                 reply.a_pintro = 0;
  495.                 reply.a_nparam = 3;
  496.                 reply.a_param[0] = 3;
  497.                 reply.a_param[1] = wininfo.y;
  498.                 reply.a_param[2] = wininfo.x;
  499.                 reply.a_inters = 0;
  500.                 reply.a_final  = 't';
  501.                 unparseseq(&reply, screen->respond);
  502.                 break;
  503.              case 14:    /* send window size (pixels) */
  504.                 reply.a_type = CSI;
  505.                 reply.a_pintro = 0;
  506.                 reply.a_nparam = 3;
  507.                 reply.a_param[0] = 4;
  508.                 reply.a_param[1] = (screen->max_col + 1) *
  509.                  FontWidth(screen) + 2 * screen->border +
  510.                  screen->scrollbar;
  511.                 reply.a_param[2] = (screen->max_row + 1) *
  512.                  FontHeight(screen) + screen->statusheight +
  513.                  Titlebar(screen) + 2 * screen->border;
  514.                 reply.a_inters = 0;
  515.                 reply.a_final  = 't';
  516.                 unparseseq(&reply, screen->respond);
  517.                 break;
  518.              case 18:    /* send window size (rows and cols) */
  519.                 reply.a_type = CSI;
  520.                 reply.a_pintro = 0;
  521.                 reply.a_nparam = 3;
  522.                 reply.a_param[0] = 8;
  523.                 reply.a_param[1] = screen->max_row + 1;
  524.                 reply.a_param[2] = screen->max_col + 1;
  525.                 reply.a_inters = 0;
  526.                 reply.a_final  = 't';
  527.                 unparseseq(&reply, screen->respond);
  528.                 break;
  529.             }
  530.             parsestate = groundtable;
  531.             break;
  532.  
  533.          case CASE_DECREQTPARM:
  534.             /* DECREQTPARM */
  535.             if ((c = param[0]) == DEFAULT)
  536.                 c = 0;
  537.             if (c == 0 || c == 1) {
  538.                 reply.a_type = CSI;
  539.                 reply.a_pintro = 0;
  540.                 reply.a_nparam = 7;
  541.                 reply.a_param[0] = c + 2;
  542.                 reply.a_param[1] = 1;    /* no parity */
  543.                 reply.a_param[2] = 1;    /* eight bits */
  544.                 reply.a_param[3] = 112;    /* transmit 9600 baud */
  545.                 reply.a_param[4] = 112;    /* receive 9600 baud */
  546.                 reply.a_param[5] = 1;    /* clock multiplier ? */
  547.                 reply.a_param[6] = 0;    /* STP flags ? */
  548.                 reply.a_inters = 0;
  549.                 reply.a_final  = 'x';
  550.                 unparseseq(&reply, screen->respond);
  551.             }
  552.             parsestate = groundtable;
  553.             break;
  554.  
  555.          case CASE_DECSET:
  556.             /* DECSET */
  557.             dpmodes(&term, bitset);
  558.             parsestate = groundtable;
  559.             if(screen->TekEmu)
  560.                 return;
  561.             break;
  562.  
  563.          case CASE_DECRST:
  564.             /* DECRST */
  565.             dpmodes(&term, bitclr);
  566.             parsestate = groundtable;
  567.             break;
  568.  
  569.          case CASE_HIDDEN:
  570.             /* special "hidden" sequence */
  571.             fprintf(stderr, "avg call = %ld char\n", ctotal/ntotal);
  572.             parsestate = groundtable;
  573.             break;
  574.  
  575.          case CASE_DECALN:
  576.             /* DECALN */
  577.             if(screen->cursor_state)
  578.                 HideCursor();
  579.             for(row = screen->max_row ; row >= 0 ; row--) {
  580.                 bzero(screen->buf[2 * row + 1],
  581.                  col = screen->max_col + 1);
  582.                 for(cp = screen->buf[2 * row] ; col > 0 ; col--)
  583.                     *cp++ = 'E';
  584.             }
  585.             ScrnRefresh(screen, 0, 0, screen->max_row + 1,
  586.              screen->max_col + 1);
  587.             parsestate = groundtable;
  588.             break;
  589.  
  590.          case CASE_GSETS:
  591.             screen->gsets[scstype] = c;
  592.             parsestate = groundtable;
  593.             break;
  594.  
  595.          case CASE_DECSC:
  596.             /* DECSC */
  597.             CursorSave(&term, &screen->sc);
  598.             parsestate = groundtable;
  599.             break;
  600.  
  601.          case CASE_DECRC:
  602.             /* DECRC */
  603.             CursorRestore(&term, &screen->sc);
  604.             parsestate = groundtable;
  605.             break;
  606.  
  607.          case CASE_DECKPAM:
  608.             /* DECKPAM */
  609.             term.keyboard.flags |= KYPD_APL;
  610.             parsestate = groundtable;
  611.             break;
  612.  
  613.          case CASE_DECKPNM:
  614.             /* DECKPNM */
  615.             term.keyboard.flags &= ~KYPD_APL;
  616.             parsestate = groundtable;
  617.             break;
  618.  
  619.          case CASE_IND:
  620.             /* IND */
  621.             /* only if not in status line */
  622.             if(!screen->instatus)
  623.                 Index(screen, 1);
  624.             if(screen->display->qlen > 0 ||
  625.              (ioctl(screen->display->fd, FIONREAD, &arg), arg) > 0)
  626.                 xevents();
  627.             parsestate = groundtable;
  628.             break;
  629.  
  630.          case CASE_NEL:
  631.             /* NEL */
  632.             /* only if not in status line */
  633.             if(!screen->instatus)
  634.                 Index(screen, 1);
  635.             CarriageReturn(screen);
  636.             if(screen->display->qlen > 0 ||
  637.              (ioctl(screen->display->fd, FIONREAD, &arg), arg) > 0)
  638.                 xevents();
  639.             parsestate = groundtable;
  640.             break;
  641.  
  642.          case CASE_HTS:
  643.             /* HTS */
  644.             TabSet(term.tabs, screen->cur_col);
  645.             parsestate = groundtable;
  646.             break;
  647.  
  648.          case CASE_RI:
  649.             /* RI */
  650.             /* only if not in status line */
  651.             if(!screen->instatus)
  652.                 RevIndex(screen, 1);
  653.             parsestate = groundtable;
  654.             break;
  655.  
  656.          case CASE_SS2:
  657.             /* SS2 */
  658.             screen->curss = 2;
  659.             parsestate = groundtable;
  660.             break;
  661.  
  662.          case CASE_SS3:
  663.             /* SS3 */
  664.             screen->curss = 3;
  665.             parsestate = groundtable;
  666.             break;
  667.  
  668.          case CASE_CSI_STATE:
  669.             /* enter csi state */
  670.             nparam = 1;
  671.             param[0] = DEFAULT;
  672.             parsestate = csitable;
  673.             break;
  674.  
  675.          case CASE_OSC:
  676.             /* do osc escapes */
  677.             do_osc(finput);
  678.             parsestate = groundtable;
  679.             break;
  680.  
  681.          case CASE_RIS:
  682.             /* RIS */
  683.             VTReset(TRUE);
  684.             parsestate = groundtable;
  685.             break;
  686.  
  687.          case CASE_LS2:
  688.             /* LS2 */
  689.             screen->curgl = 2;
  690.             parsestate = groundtable;
  691.             break;
  692.  
  693.          case CASE_LS3:
  694.             /* LS3 */
  695.             screen->curgl = 3;
  696.             parsestate = groundtable;
  697.             break;
  698.  
  699.          case CASE_LS3R:
  700.             /* LS3R */
  701.             screen->curgr = 3;
  702.             parsestate = groundtable;
  703.             break;
  704.  
  705.          case CASE_LS2R:
  706.             /* LS2R */
  707.             screen->curgr = 2;
  708.             parsestate = groundtable;
  709.             break;
  710.  
  711.          case CASE_LS1R:
  712.             /* LS1R */
  713.             screen->curgr = 1;
  714.             parsestate = groundtable;
  715.             break;
  716.  
  717.          case CASE_TO_STATUS:
  718.             if((c = param[0]) < 1)
  719.                 c = 1;
  720.             ToStatus(c - 1);
  721.             parsestate = groundtable;
  722.             break;
  723.  
  724.          case CASE_FROM_STATUS:
  725.             FromStatus();
  726.             parsestate = groundtable;
  727.             break;
  728.  
  729.          case CASE_SHOW_STATUS:
  730.             ShowStatus();
  731.             parsestate = groundtable;
  732.             break;
  733.  
  734.          case CASE_HIDE_STATUS:
  735.             HideStatus();
  736.             parsestate = groundtable;
  737.             break;
  738.  
  739.          case CASE_ERASE_STATUS:
  740.             EraseStatus();
  741.             parsestate = groundtable;
  742.             break;
  743.  
  744.          case CASE_XTERM_SAVE:
  745.             savemodes(&term);
  746.             parsestate = groundtable;
  747.             break;
  748.  
  749.          case CASE_XTERM_RESTORE:
  750.             restoremodes(&term);
  751.             parsestate = groundtable;
  752.             break;
  753.  
  754.          case CASE_PRINT:
  755.             /* printable characters */
  756.             top = bcnt > TEXT_BUF_SIZE ? TEXT_BUF_SIZE : bcnt;
  757.             cp = bptr;
  758.             *--bptr = c;
  759.             while(top > 0 && isprint(*cp)) {
  760.                 top--;
  761.                 bcnt--;
  762.                 cp++;
  763.             }
  764.             if(screen->curss) {
  765.                 dotext(screen, term.flags,
  766.                  screen->gsets[screen->curss], bptr, bptr + 1);
  767.                 screen->curss = 0;
  768.                 bptr++;
  769.             }
  770.             if(bptr < cp)
  771.                 dotext(screen, term.flags,
  772.                  screen->gsets[screen->curgl], bptr, cp);
  773.             bptr = cp;
  774.             break;
  775.         }
  776. }
  777.  
  778. finput()
  779. {
  780.     return(input());
  781. }
  782.  
  783. static int select_mask;
  784.  
  785. in_put()
  786. {
  787.     register Screen *screen = &term.screen;
  788.     register char *cp;
  789.     register int i;
  790.  
  791.     select_mask = pty_mask;    /* force initial read */
  792.     for( ; ; ) {
  793.         if(select_mask & pty_mask) {
  794.             if(screen->logging)
  795.                 FlushLog(screen);
  796.             if((bcnt = read(screen->respond, bptr = buffer,
  797.              BUF_SIZE)) < 0) {
  798.                 if(errno == EIO && am_slave)
  799.                     exit(0);
  800.                 else if(errno != EWOULDBLOCK)
  801.                     Panic(
  802.                  "input: read returned unexpected error (%d)\n",
  803.                      errno);
  804.             } else if(bcnt == 0)
  805.                 Panic("input: read returned zero\n");
  806.             else {
  807.                 /* strip parity bit */
  808.                 for(i = bcnt, cp = bptr ; i > 0 ; i--)
  809.                     *cp++ &= CHAR;
  810.                 if(screen->sb && screen->scrollinput &&
  811.                  screen->topline < 0)
  812.                     ScrollToBottom(screen->sb);
  813.                 if(screen->icon_show && !screen->iconinput) {
  814.                     screen->iconinput = TRUE;
  815.                     IconBox(screen);
  816.                 }
  817.                 break;
  818.             }
  819.         }
  820.         if(screen->scroll_amt)
  821.             FlushScroll(screen);
  822.         if(screen->cursor_set && (screen->cursor_col != screen->cur_col
  823.          || screen->cursor_row != screen->cur_row)) {
  824.             if(screen->cursor_state)
  825.                 HideCursor();
  826.             ShowCursor();
  827.         } else if(screen->cursor_set != screen->cursor_state) {
  828.             if(screen->cursor_set)
  829.                 ShowCursor();
  830.             else
  831.                 HideCursor();
  832.         }
  833.         if(QLength())
  834.             select_mask = X_mask;
  835.         else {
  836.             XFlush();
  837.             select_mask = Select_mask;
  838.             if((i = select(max_plus1, &select_mask, NULL, NULL,
  839.              screen->timeout)) < 0){
  840.                 if (errno != EINTR)
  841.                     SysError(ERROR_SELECT);
  842.                 continue;
  843.             } else if(i == 0) {
  844.                 if(GetButtonState(screen->sb) & HILITED)
  845.                     WindowScroll(screen,
  846.                      ButtonRegion(screen->sb));
  847.                 screen->timeout->tv_usec = STEPTIME;
  848.                 continue;
  849.             }
  850.         }
  851.         if(select_mask & X_mask)
  852.             xevents();
  853.     }
  854.     bcnt--;
  855.     return(*bptr++);
  856. }
  857.  
  858. /*
  859.  * process a string of characters according to the character set indicated
  860.  * by charset.  worry about end of line conditions (wraparound if selected).
  861.  */
  862. dotext(screen, flags, charset, buf, ptr)
  863. register Screen    *screen;
  864. unsigned    flags;
  865. char        charset;
  866. char    *buf;
  867. char    *ptr;
  868. {
  869.     register char    *s;
  870.     register int    len;
  871.     register int    n;
  872.     register int    next_col;
  873.  
  874.     switch (charset) {
  875.     case 'A':    /* United Kingdom set                */
  876.         for (s=buf; s<ptr; ++s)
  877.             if (*s == '#')
  878.                 *s = '\036';    /* UK pound sign    */
  879.         break;
  880.  
  881.     case 'B':    /* ASCII set                    */
  882.         break;
  883.  
  884.     case '0':    /* special graphics (line drawing)        */
  885.         for (s=buf; s<ptr; ++s)
  886.             if (*s>=0x5f && *s<=0x7e)
  887.                 *s = *s == 0x5f ? 0x7f : *s - 0x5f;
  888.         break;
  889.  
  890.     default:    /* any character sets we don't recognize    */
  891.         return;
  892.     }
  893.  
  894.     len = ptr - buf; 
  895.     ptr = buf;
  896.     while (len > 0) {
  897.         n = screen->max_col-screen->cur_col+1;
  898.         if (n <= 1) {
  899.             if (screen->do_wrap && (flags&WRAPAROUND) &&
  900.              !screen->instatus) {
  901.                 Index(screen, 1);
  902.                 screen->cur_col = 0;
  903.                 screen->do_wrap = 0;
  904.                 n = screen->max_col+1;
  905.             } else
  906.                 n = 1;
  907.         }
  908.         if (len < n)
  909.             n = len;
  910.         next_col = screen->cur_col + n;
  911.         WriteText(screen, ptr, n, flags);
  912.         /*
  913.          * the call to WriteText updates screen->cur_col.
  914.          * If screen->cur_col != next_col, we must have
  915.          * hit the right margin, so set the do_wrap flag.
  916.          */
  917.         screen->do_wrap = (screen->cur_col < next_col);
  918.         len -= n;
  919.         ptr += n;
  920.     }
  921. }
  922.  
  923. /*
  924.  * write a string str of length len onto the screen at
  925.  * the current cursor position.  update cursor position.
  926.  */
  927. WriteText(screen, str, len, flags)
  928. register Screen    *screen;
  929. register char    *str;
  930. register int    len;
  931. unsigned    flags;
  932. {
  933.     register int pix, cx, cy;
  934.     register unsigned fgs = flags;
  935.     Font    fnt;
  936.  
  937.    if(screen->instatus && screen->reversestatus)
  938.     fgs ^= INVERSE;
  939.    if(screen->cur_row - screen->topline <= screen->max_row ||
  940.      screen->instatus) {
  941.     /*
  942.     if(screen->cur_row == screen->cursor_row && screen->cur_col <=
  943.      screen->cursor_col && screen->cursor_col <= screen->cur_col + len - 1)
  944.         screen->cursor_state = OFF;
  945.      */
  946.     if(screen->cursor_state)
  947.         HideCursor();
  948.      fnt = ActiveIcon(screen) ? screen->fnt_icon
  949.           : (fgs & BOLD) ? screen->fnt_bold : screen->fnt_norm;
  950.     if (fgs & INSERT)
  951.         InsertChar(screen, len);
  952.       if (!(AddToRefresh(screen))) {
  953.         if(screen->scroll_amt)
  954.             FlushScroll(screen);
  955.     cx = CursorX(screen, screen->cur_col);
  956.     cy = CursorY(screen, screen->cur_row);
  957.     if (screen->show || ActiveIcon(screen)) {
  958.         if (fgs & INVERSE)
  959.         XText(VWindow(screen), cx, cy, str, len, fnt,
  960.          pix = screen->background, screen->foreground);
  961.         else
  962.          XText(VWindow(screen), cx, cy, str, len, fnt,
  963.          pix = screen->foreground, screen->background);
  964.         if((fgs & BOLD) && screen->enbolden)
  965.         XTextMask(VWindow(screen), cx + 1, cy, str, len, fnt, pix);
  966.         if(fgs & UNDERLINE) {
  967.         cy += FontHeight(screen) - 2;
  968.         XLine(VWindow(screen), cx, cy, cx + len * FontWidth(screen),
  969.          cy, 1, 1, pix, GXcopy, AllPlanes);
  970.         }
  971.     }
  972.     /*
  973.      * the following statements compile data to compute the average 
  974.      * number of characters written on each call to XText.  The data
  975.      * may be examined via the use of a "hidden" escape sequence.
  976.      */
  977.     ctotal += len;
  978.     ++ntotal;
  979.       }
  980.     }
  981.     ScreenWrite(screen, str, flags, len);
  982.     CursorForward(screen, len);
  983. }
  984.  
  985. /*
  986.  * process ANSI modes set, reset
  987.  */
  988. modes(term, func)
  989. Terminal    *term;
  990. int        (*func)();
  991. {
  992.     register Screen    *screen    = &term->screen;
  993.     register int    i;
  994.  
  995.     for (i=0; i<nparam; ++i) {
  996.         switch (param[i]) {
  997.         case 4:            /* IRM                */
  998.             (*func)(&term->flags, INSERT);
  999.             break;
  1000.  
  1001.         case 20:        /* LNM                */
  1002.             (*func)(&term->flags, LINEFEED);
  1003.             break;
  1004.         }
  1005.     }
  1006. }
  1007.  
  1008. /*
  1009.  * process DEC private modes set, reset
  1010.  */
  1011. dpmodes(term, func)
  1012. Terminal    *term;
  1013. int        (*func)();
  1014. {
  1015.     register Screen    *screen    = &term->screen;
  1016.     register int    i, j;
  1017.     extern int bitset();
  1018.  
  1019.     for (i=0; i<nparam; ++i) {
  1020.         switch (param[i]) {
  1021.         case 1:            /* DECCKM            */
  1022.             (*func)(&term->keyboard.flags, CURSOR_APL);
  1023.             break;
  1024.         case 3:            /* DECCOLM            */
  1025.             if(screen->c132) {
  1026.                 ClearScreen(screen);
  1027.                 CursorSet(screen, 0, 0, term->flags);
  1028.                 if((j = func == bitset ? 132 : 80) !=
  1029.                  ((term->flags & IN132COLUMNS) ? 132 : 80) ||
  1030.                  j != screen->max_col + 1) {
  1031.                     XChangeWindow (VWindow(screen),
  1032.                      FontWidth(screen) * j + 2*screen->border
  1033.                      + screen->scrollbar,
  1034.                      FontHeight(screen) * (screen->max_row
  1035.                      + 1) + screen->statusheight +
  1036.                      Titlebar(screen) + 2 * screen->border);
  1037.                     XSync(FALSE);    /* synchronize */
  1038.                     if(QLength() > 0)
  1039.                         xevents();
  1040.                 }
  1041.                 (*func)(&term->flags, IN132COLUMNS);
  1042.             }
  1043.             break;
  1044.         case 4:            /* DECSCLM (slow scroll)    */
  1045.             if (func == bitset) {
  1046.                 screen->jumpscroll = 0;
  1047.                 if (screen->scroll_amt)
  1048.                     FlushScroll(screen);
  1049.             } else
  1050.                 screen->jumpscroll = 1;
  1051.             (*func)(&term->flags, SMOOTHSCROLL);
  1052.             break;
  1053.         case 5:            /* DECSCNM            */
  1054.             j = term->flags;
  1055.             (*func)(&term->flags, REVERSE_VIDEO);
  1056.             if ((term->flags ^ j) & REVERSE_VIDEO)
  1057.                 ReverseVideo(term);
  1058.             break;
  1059.  
  1060.         case 6:            /* DECOM            */
  1061.             (*func)(&term->flags, ORIGIN);
  1062.             CursorSet(screen, 0, 0, term->flags);
  1063.             break;
  1064.  
  1065.         case 7:            /* DECAWM            */
  1066.             (*func)(&term->flags, WRAPAROUND);
  1067.             break;
  1068.         case 8:            /* DECARM            */
  1069.             j = term->flags;
  1070.             (*func)(&term->flags, AUTOREPEAT);
  1071.             if ((term->flags ^ j) & AUTOREPEAT)
  1072.                 if(term->flags & AUTOREPEAT)
  1073.                     XAutoRepeatOn();
  1074.                 else
  1075.                     XAutoRepeatOff();
  1076.             break;
  1077.         case 9:            /* MIT bogus sequence        */
  1078.             (*func)(&screen->send_mouse_pos, 1);
  1079.             break;
  1080.         case 38:        /* DECTEK            */
  1081.             if(func == bitset & !(screen->inhibit & I_TEK)) {
  1082.                 if(screen->logging) {
  1083.                     FlushLog(screen);
  1084.                     screen->logstart = Tbuffer;
  1085.                 }
  1086.                 screen->TekEmu = TRUE;
  1087.             }
  1088.             break;
  1089.         case 40:        /* 132 column mode        */
  1090.             (*func)(&screen->c132, 1);
  1091.             break;
  1092.         case 41:        /* curses hack            */
  1093.             (*func)(&screen->curses, 1);
  1094.             break;
  1095.         case 42:        /* scrollbar            */
  1096.             if(func == bitset)
  1097.                 ScrollBarOn(screen, TRUE, FALSE);
  1098.             else
  1099.                 ScrollBarOff(screen);
  1100.             break;
  1101.         case 43:        /* lines off top        */
  1102.             if(screen->sb)
  1103.                 SetSaveState(screen->sb, (func == bitset));
  1104.             break;
  1105.         case 44:        /* margin bell            */
  1106.             (*func)(&screen->marginbell, 1);
  1107.             if(!screen->marginbell)
  1108.                 screen->bellarmed = -1;
  1109.             break;
  1110.         case 45:        /* reverse wraparound    */
  1111.             (*func)(&term->flags, REVERSEWRAP);
  1112.             break;
  1113.         case 46:        /* logging        */
  1114.             if(func == bitset)
  1115.                 StartLog(screen);
  1116.             else
  1117.                 CloseLog(screen);
  1118.             break;
  1119.         case 47:        /* alternate buffer        */
  1120.             if(func == bitset)
  1121.                 ToAlternate(screen);
  1122.             else
  1123.                 FromAlternate(screen);
  1124.             break;
  1125.         case 48:        /* reverse status line    */
  1126.             j = screen->reversestatus;
  1127.             (*func)(&screen->reversestatus, 1);
  1128.             if(j != screen->reversestatus)
  1129.                 ScrnRefresh(screen, screen->max_row + 1, 0, 1,
  1130.                  screen->max_col + 1);
  1131.             break;
  1132.         case 49:        /* page mode        */
  1133.             j = screen->pagemode;
  1134.             (*func)(&screen->pagemode, 1);
  1135.             if(!j && screen->pagemode)
  1136.                 screen->pagecnt = 0;
  1137.             break;
  1138.         }
  1139.     }
  1140. }
  1141.  
  1142. /*
  1143.  * process xterm private modes save
  1144.  */
  1145. savemodes(term)
  1146. Terminal *term;
  1147. {
  1148.     register Screen    *screen    = &term->screen;
  1149.     register int i;
  1150.  
  1151.     for (i = 0; i < nparam; i++) {
  1152.         switch (param[i]) {
  1153.         case 1:            /* DECCKM            */
  1154.             screen->save_modes[0] = term->keyboard.flags &
  1155.              CURSOR_APL;
  1156.             break;
  1157.         case 3:            /* DECCOLM            */
  1158.             if(screen->c132)
  1159.                 screen->save_modes[1] = term->flags &
  1160.                  IN132COLUMNS;
  1161.             break;
  1162.         case 4:            /* DECSCLM (slow scroll)    */
  1163.             screen->save_modes[2] = term->flags & SMOOTHSCROLL;
  1164.             break;
  1165.         case 5:            /* DECSCNM            */
  1166.             screen->save_modes[3] = term->flags & REVERSE_VIDEO;
  1167.             break;
  1168.         case 6:            /* DECOM            */
  1169.             screen->save_modes[4] = term->flags & ORIGIN;
  1170.             break;
  1171.  
  1172.         case 7:            /* DECAWM            */
  1173.             screen->save_modes[5] = term->flags & WRAPAROUND;
  1174.             break;
  1175.         case 8:            /* DECARM            */
  1176.             screen->save_modes[6] = term->flags & AUTOREPEAT;
  1177.             break;
  1178.         case 9:            /* MIT bogus sequence        */
  1179.             screen->save_modes[7] = screen->send_mouse_pos;
  1180.             break;
  1181.         case 40:        /* 132 column mode        */
  1182.             screen->save_modes[8] = screen->c132;
  1183.             break;
  1184.         case 41:        /* curses hack            */
  1185.             screen->save_modes[9] = screen->curses;
  1186.             break;
  1187.         case 42:        /* scrollbar            */
  1188.             screen->save_modes[10] = screen->scrollbar;
  1189.             break;
  1190.         case 43:        /* lines off top        */
  1191.             if(screen->sb)
  1192.                 screen->save_modes[11] =
  1193.                  GetSaveState(screen->sb);
  1194.             break;
  1195.         case 44:        /* margin bell            */
  1196.             screen->save_modes[12] = screen->marginbell;
  1197.             break;
  1198.         case 45:        /* reverse wraparound    */
  1199.             screen->save_modes[13] = term->flags & REVERSEWRAP;
  1200.             break;
  1201.         case 46:        /* logging        */
  1202.             screen->save_modes[14] = screen->logging;
  1203.             break;
  1204.         case 47:        /* alternate buffer        */
  1205.             screen->save_modes[15] = screen->alternate;
  1206.             break;
  1207.         case 48:        /* reverse status line        */
  1208.             screen->save_modes[16] = screen->reversestatus;
  1209.             break;
  1210.         case 49:        /* page mode            */
  1211.             screen->save_modes[17] = screen->pagemode;
  1212.             screen->save_modes[18] = screen->pagecnt;
  1213.             break;
  1214.         }
  1215.     }
  1216. }
  1217.  
  1218. /*
  1219.  * process xterm private modes restore
  1220.  */
  1221. restoremodes(term)
  1222. Terminal *term;
  1223. {
  1224.     register Screen    *screen    = &term->screen;
  1225.     register int i, j;
  1226.  
  1227.     for (i = 0; i < nparam; i++) {
  1228.         switch (param[i]) {
  1229.         case 1:            /* DECCKM            */
  1230.             term->keyboard.flags &= ~CURSOR_APL;
  1231.             term->keyboard.flags |= screen->save_modes[0] &
  1232.              CURSOR_APL;
  1233.             break;
  1234.         case 3:            /* DECCOLM            */
  1235.             if(screen->c132) {
  1236.                 ClearScreen(screen);
  1237.                 CursorSet(screen, 0, 0, term->flags);
  1238.                 if((j = (screen->save_modes[1] & IN132COLUMNS)
  1239.                  ? 132 : 80) != ((term->flags & IN132COLUMNS)
  1240.                  ? 132 : 80) || j != screen->max_col + 1) {
  1241.                     XChangeWindow (VWindow(screen),
  1242.                      FontWidth(screen) * j + 2*screen->border
  1243.                      + screen->scrollbar,
  1244.                      FontHeight(screen) * (screen->max_row
  1245.                      + 1) + screen->statusheight +
  1246.                      Titlebar(screen) + 2 * screen->border);
  1247.                     XSync(FALSE);    /* synchronize */
  1248.                     if(QLength() > 0)
  1249.                         xevents();
  1250.                 }
  1251.                 term->flags &= ~IN132COLUMNS;
  1252.                 term->flags |= screen->save_modes[1] &
  1253.                  IN132COLUMNS;
  1254.             }
  1255.             break;
  1256.         case 4:            /* DECSCLM (slow scroll)    */
  1257.             if (screen->save_modes[2] & SMOOTHSCROLL) {
  1258.                 screen->jumpscroll = 0;
  1259.                 if (screen->scroll_amt)
  1260.                     FlushScroll(screen);
  1261.             } else
  1262.                 screen->jumpscroll = 1;
  1263.             term->flags &= ~SMOOTHSCROLL;
  1264.             term->flags |= screen->save_modes[2] & SMOOTHSCROLL;
  1265.             break;
  1266.         case 5:            /* DECSCNM            */
  1267.             if((screen->save_modes[3] ^ term->flags) &
  1268.              REVERSE_VIDEO) {
  1269.                 term->flags &= ~REVERSE_VIDEO;
  1270.                 term->flags |= screen->save_modes[3] &
  1271.                  REVERSE_VIDEO;
  1272.                 ReverseVideo(term);
  1273.             }
  1274.             break;
  1275.         case 6:            /* DECOM            */
  1276.             term->flags &= ~ORIGIN;
  1277.             term->flags |= screen->save_modes[4] & ORIGIN;
  1278.             CursorSet(screen, 0, 0, term->flags);
  1279.             break;
  1280.  
  1281.         case 7:            /* DECAWM            */
  1282.             term->flags &= ~WRAPAROUND;
  1283.             term->flags |= screen->save_modes[5] & WRAPAROUND;
  1284.             break;
  1285.         case 8:            /* DECARM            */
  1286.             if((screen->save_modes[6] ^ term->flags) & AUTOREPEAT) {
  1287.                 term->flags &= ~REVERSE_VIDEO;
  1288.                 term->flags |= screen->save_modes[6] &
  1289.                  REVERSE_VIDEO;
  1290.                 if(term->flags & AUTOREPEAT)
  1291.                     XAutoRepeatOn();
  1292.                 else
  1293.                     XAutoRepeatOff();
  1294.             }
  1295.             break;
  1296.         case 9:            /* MIT bogus sequence        */
  1297.             screen->send_mouse_pos = screen->save_modes[7];
  1298.             break;
  1299.         case 40:        /* 132 column mode        */
  1300.             screen->c132 = screen->save_modes[8];
  1301.             break;
  1302.         case 41:        /* curses hack            */
  1303.             screen->curses = screen->save_modes[9];
  1304.             break;
  1305.         case 42:        /* scrollbar            */
  1306.             if(screen->save_modes[10])
  1307.                 ScrollBarOn(screen, TRUE, FALSE);
  1308.             else
  1309.                 ScrollBarOff(screen);
  1310.             break;
  1311.         case 43:        /* lines off top        */
  1312.             if(screen->sb)
  1313.                 SetSaveState(screen->sb,screen->save_modes[11]);
  1314.             break;
  1315.         case 44:        /* margin bell            */
  1316.             if(!(screen->marginbell = screen->save_modes[12]))
  1317.                 screen->bellarmed = -1;
  1318.             break;
  1319.         case 45:        /* reverse wraparound    */
  1320.             term->flags &= ~REVERSEWRAP;
  1321.             term->flags |= screen->save_modes[13] & REVERSEWRAP;
  1322.             break;
  1323.         case 46:        /* logging        */
  1324.             if(screen->save_modes[14])
  1325.                 StartLog(screen);
  1326.             else
  1327.                 CloseLog(screen);
  1328.             break;
  1329.         case 47:        /* alternate buffer        */
  1330.             if(screen->save_modes[15])
  1331.                 ToAlternate(screen);
  1332.             else
  1333.                 FromAlternate(screen);
  1334.             break;
  1335.         case 48:        /* reverse status line        */
  1336.             if(screen->save_modes[16] != screen->reversestatus) {
  1337.                 screen->reversestatus = 
  1338.                  screen->save_modes[16];
  1339.                 ScrnRefresh(screen, screen->max_row + 1, 0, 1,
  1340.                  screen->max_col + 1);
  1341.             }
  1342.             break;
  1343.         case 49:        /* page mode            */
  1344.             screen->pagemode = screen->save_modes[17];
  1345.             screen->pagecnt = screen->save_modes[18];
  1346.             break;
  1347.         }
  1348.     }
  1349. }
  1350.  
  1351. /*
  1352.  * set a bit in a word given a pointer to the word and a mask.
  1353.  */
  1354. bitset(p, mask)
  1355. int    *p;
  1356. {
  1357.     *p |= mask;
  1358. }
  1359.  
  1360. /*
  1361.  * clear a bit in a word given a pointer to the word and a mask.
  1362.  */
  1363. bitclr(p, mask)
  1364. int    *p;
  1365. {
  1366.     *p &= ~mask;
  1367. }
  1368.  
  1369. unparseseq(ap, fd)
  1370. register ANSI    *ap;
  1371. {
  1372.     register int    c;
  1373.     register int    i;
  1374.     register int    inters;
  1375.  
  1376.     c = ap->a_type;
  1377.     if (c>=0x80 && c<=0x9F) {
  1378.         unparseputc(ESC, fd);
  1379.         c -= 0x40;
  1380.     }
  1381.     unparseputc(c, fd);
  1382.     c = ap->a_type;
  1383.     if (c==ESC || c==DCS || c==CSI || c==OSC || c==PM || c==APC) {
  1384.         if (ap->a_pintro != 0)
  1385.             unparseputc(ap->a_pintro, fd);
  1386.         for (i=0; i<ap->a_nparam; ++i) {
  1387.             if (i != 0)
  1388.                 unparseputc(';', fd);
  1389.             unparseputn(ap->a_param[i], fd);
  1390.         }
  1391.         inters = ap->a_inters;
  1392.         for (i=3; i>=0; --i)
  1393.             c = (inters >> (8*i)) & 0xff;
  1394.             if (c != 0)
  1395.                 unparseputc(c, fd);
  1396.         unparseputc(ap->a_final, fd);
  1397.     }
  1398. }
  1399.  
  1400. unparseputn(n, fd)
  1401. unsigned int    n;
  1402. {
  1403.     unsigned int    q;
  1404.  
  1405.     q = n/10;
  1406.     if (q != 0)
  1407.         unparseputn(q, fd);
  1408.     unparseputc((n%10) + '0', fd);
  1409. }
  1410.  
  1411. unparseputc(c, fd)
  1412. {
  1413.     char    buf[2];
  1414.     register i = 1;
  1415.     extern Terminal term;
  1416.  
  1417.     if((buf[0] = c) == '\r' && (term.flags & LINEFEED)) {
  1418.         buf[1] = '\n';
  1419.         i++;
  1420.     }
  1421.     if (write(fd, buf, i) != i)
  1422.         Panic("unparseputc: error writing character\n", 0);
  1423. }
  1424.  
  1425. static int alt_pagecnt;
  1426. static int alt_pagemode;
  1427. static int alt_saving;
  1428.  
  1429. ToAlternate(screen)
  1430. register Screen *screen;
  1431. {
  1432.     extern ScrnBuf Allocate();
  1433.  
  1434.     if(screen->alternate)
  1435.         return;
  1436.     if(!screen->altbuf)
  1437.         screen->altbuf = Allocate(screen->max_row + 1, screen->max_col
  1438.          + 1);
  1439.     if(screen->sb) {
  1440.         alt_saving = GetSaveState(screen->sb);
  1441.         SetSaveState(screen->sb, FALSE);
  1442.     } else
  1443.         alt_saving = TRUE;
  1444.     if(alt_pagemode = screen->pagemode)
  1445.         alt_pagecnt = screen->pagecnt;
  1446.     screen->pagemode = FALSE;
  1447.     SwitchBufs(screen);
  1448.     screen->alternate = TRUE;
  1449. }
  1450.  
  1451. FromAlternate(screen)
  1452. register Screen *screen;
  1453. {
  1454.     if(!screen->alternate)
  1455.         return;
  1456.     screen->alternate = FALSE;
  1457.     if(screen->sb)
  1458.         SetSaveState(screen->sb, alt_saving);
  1459.     if(screen->pagemode = alt_pagemode)
  1460.         screen->pagecnt = alt_pagecnt;
  1461.     SwitchBufs(screen);
  1462. }
  1463.  
  1464. SwitchBufs(screen)
  1465. register Screen *screen;
  1466. {
  1467.     register int rows, top;
  1468.     char *save [2 * MAX_ROWS];
  1469.  
  1470.     if(screen->cursor_state)
  1471.         HideCursor();
  1472.     rows = screen->max_row + 1;
  1473.     bcopy((char *)screen->buf, (char *)save, 2 * sizeof(char *) * rows);
  1474.     bcopy((char *)screen->altbuf, (char *)screen->buf, 2 * sizeof(char *) *
  1475.      rows);
  1476.     bcopy((char *)save, (char *)screen->altbuf, 2 * sizeof(char *) * rows);
  1477.  
  1478.     if((top = -screen->topline) <= screen->max_row) {
  1479.         if(screen->scroll_amt)
  1480.             FlushScroll(screen);
  1481.         if(top == 0 && !screen->statusline)
  1482.             XClear(VWindow(screen));
  1483.         else
  1484.             XTileSet(VWindow(screen), screen->border, top *
  1485.              FontHeight(screen) + screen->border + Titlebar(screen),
  1486.              Width(screen), (screen->max_row - top + 1) *
  1487.              FontHeight(screen), screen->bgndtile);
  1488.     }
  1489.     ScrnRefresh(screen, 0, 0, rows, screen->max_col + 1);
  1490. }
  1491.  
  1492. VTRun()
  1493. {
  1494.     register Screen *screen = &term.screen;
  1495.     register int i;
  1496.     
  1497.     if(!VWindow(screen) && !VTInit()) {
  1498.         if(TWindow(screen)) {
  1499.             screen->TekEmu = TRUE;
  1500.             return;
  1501.         }
  1502.         Exit(ERROR_VINIT);
  1503.     }
  1504.     screen->cursor_state = OFF;
  1505.     screen->cursor_set = ON;
  1506.     if(screen->icon_show) {
  1507.         if(screen->icon_show < 0) {
  1508.             screen->icon_show = TRUE;
  1509.             screen->mappedVwin = &screen->iconVwin;
  1510.             XMapWindow(screen->iconVwin.window);
  1511.         }
  1512.     } else if(!screen->show) {
  1513.         screen->show = TRUE;
  1514.         screen->mappedVwin = &screen->fullVwin;
  1515.         XMapWindow(VWindow(screen));
  1516.     } else
  1517.         XRaiseWindow(VWindow(screen));
  1518.     if(screen->select)
  1519.         VTSelect();
  1520.     if (L_flag > 0) {
  1521.         XWarpMouse (VWindow(screen),
  1522.                 FullWidth(screen) >> 1, FullHeight(screen) >>1);
  1523.         L_flag = -1;
  1524.     }
  1525.     bcnt = 0;
  1526.     bptr = buffer;
  1527.     while(Tpushb > Tpushback) {
  1528.         *bptr++ = *--Tpushb;
  1529.         bcnt++;
  1530.     }
  1531.     bcnt += (i = Tbcnt);
  1532.     for( ; i > 0 ; i--)
  1533.         *bptr++ = *Tbptr++;
  1534.     bptr = buffer;
  1535.     if(!setjmp(VTend))
  1536.         VTparse();
  1537.     HideCursor();
  1538.     screen->cursor_set = OFF;
  1539.     VTUnselect();
  1540. }
  1541.  
  1542. VTInit()
  1543. {
  1544.     int width, height;
  1545.     FontInfo *fInfo, *ifInfo;
  1546.     register Screen *screen = &term.screen;
  1547.     register Vertex *vp;
  1548.     register int i, j;
  1549.     char *def = "=80x24+1+1";
  1550.     char iconname[128];
  1551.     static short failed;
  1552.     Color cdef;
  1553.     OpaqueFrame twindow;
  1554.     WindowInfo wininfo;
  1555.     int x, y;
  1556.     Window win;
  1557.     extern char *malloc();
  1558.  
  1559.     if(failed)
  1560.         return(FALSE);
  1561.     
  1562.     screen->mappedVwin = &screen->fullVwin;
  1563.  
  1564.     TabReset (term.tabs);
  1565.  
  1566.     screen->fnt_norm = screen->fnt_bold = screen->fnt_icon = NULL;
  1567.        
  1568.     if ((fInfo = XOpenFont(f_n)) == NULL) {
  1569.         fprintf(stderr, "%s: Could not open font %s!\n",
  1570.             xterm_name, f_n);
  1571.         failed = TRUE;
  1572.         return(FALSE);
  1573.     }
  1574.     screen->fnt_norm = fInfo->id;
  1575.     if (!f_b || !(screen->fnt_bold = XGetFont(f_b))) {
  1576.         screen->fnt_bold = screen->fnt_norm;
  1577.         screen->enbolden = TRUE;
  1578.     }
  1579.     screen->fullVwin.f_width = fInfo->width;
  1580.     screen->fullVwin.f_height = fInfo->height;
  1581.     
  1582.     if (screen->active_icon) {
  1583.         if (!screen->fnt_icon) {
  1584.         if ((ifInfo = XOpenFont(f_i)) == NULL) {
  1585.             fprintf( stderr, "%s: Could not open font %s!\n",
  1586.                  xterm_name, f_i);
  1587.             failed = TRUE;
  1588.             return( FALSE );
  1589.         }
  1590.         screen->fnt_icon = ifInfo->id;
  1591.         } else
  1592.             XQueryFont( screen->fnt_icon, &ifInfo );
  1593.  
  1594.         screen->iconVwin.f_width = ifInfo->width;
  1595.         screen->iconVwin.f_height = ifInfo->height;
  1596.     }
  1597.  
  1598.     screen->curs = make_xterm(screen->mousecolor, screen->background,
  1599.      GXcopy);
  1600.  
  1601.     twindow.bdrwidth = screen->borderwidth;
  1602.     twindow.border = screen->graybordertile;
  1603.     twindow.background = screen->bgndtile;
  1604.     if((screen->minrows = (MINSCROLLBARHEIGHT - 2 * screen->border +
  1605.      fInfo->height - 1) / fInfo->height) < 0)
  1606.         screen->minrows = 0;
  1607.  
  1608.     i = 2 * screen->border + screen->scrollbar;
  1609.     j = 2 * screen->border + Titlebar(screen);
  1610.     if(screen->statusline)
  1611.         j += (screen->statusheight = fInfo->height + 2);
  1612.  
  1613.     if((screen->fullVwin.window = XCreateTerm ("Terminal Emulator", xterm_name,
  1614.      geo_metry, def, &twindow, 12, screen->minrows, i, j, &width, &height,
  1615.      fInfo, fInfo->width, fInfo->height)) == NULL) {
  1616.         fprintf(stderr, "%s: Can't create VT window\n");
  1617.         XCloseFont(fInfo);
  1618.         return(FALSE);
  1619.     }
  1620.     XSelectInput(VWindow(screen), WINDOWEVENTS);
  1621.     /*
  1622.      * XCreateTerm flushes all events, which might include an EnterWindow
  1623.      * or LeaveWindow.  So if the cursor is not where it is supposed to
  1624.      * be, we set select to the appropriate thing.
  1625.      */
  1626.     if(TWindow(screen) && XQueryMouse(RootWindow, &x, &y, &win)) {
  1627.         if(screen->timer) {
  1628.             Timer(0L);
  1629.             screen->timer = 0;
  1630.         }
  1631.         if(win == TWindow(screen))
  1632.             screen->select |= INWINDOW;
  1633.         else
  1634.             screen->select &= ~INWINDOW;
  1635.     }
  1636.  
  1637.     screen->fullVwin.fullwidth = twindow.width;
  1638.     screen->fullVwin.fullheight = twindow.height;
  1639.     screen->fullVwin.width = twindow.width - i;
  1640.     screen->fullVwin.height = twindow.height - j;
  1641.  
  1642.     /* Reset variables used by ANSI emulation. */
  1643.  
  1644.     screen->gsets[0] = 'B';            /* ASCII_G        */
  1645.     screen->gsets[1] = 'B';
  1646.     screen->gsets[2] = 'B';            /* DEC supplemental.    */
  1647.     screen->gsets[3] = 'B';
  1648.     screen->curgl = 0;            /* G0 => GL.        */
  1649.     screen->curgr = 2;            /* G2 => GR.        */
  1650.     screen->curss = 0;            /* No single shift.    */
  1651.  
  1652.     if(screen->iconTwin.window) {
  1653.         XQueryWindow(screen->iconTwin.window, &wininfo);
  1654.         x = wininfo.x;
  1655.         y = wininfo.y;
  1656.     } else {
  1657.         x = twindow.x + (twindow.width - screen->iconVwin.width) / 2;
  1658.         y = twindow.y + (twindow.height - screen->iconVwin.height) / 2;
  1659.         IconGeometry(screen, &x, &y);
  1660.     }
  1661.     screen->iconVwin.window =
  1662.         XCreateWindow( RootWindow, x, y, 1, 1, screen->borderwidth,
  1663.                    screen->bordertile, screen->bgndtile );
  1664.  
  1665.     XSetIconWindow( screen->fullVwin.window, screen->iconVwin.window );
  1666.  
  1667.     XDefineCursor( screen->iconVwin.window, screen->arrow );
  1668.     XSelectInput( screen->iconVwin.window,
  1669.               screen->active_icon && (term.flags & ICONINPUT)
  1670.             ? ICONWINDOWEVENTS | ICONINPUTEVENTS
  1671.                 : ICONWINDOWEVENTS );
  1672.  
  1673.     XDefineCursor( VWindow(screen), screen->curs );
  1674.     XStoreName (VWindow(screen), screen->winname);
  1675.     strcpy(iconname, screen->winname);
  1676.     strcat(iconname, " (icon)");
  1677.     XStoreName (screen->iconVwin.window, iconname);
  1678.     XSetResizeHint (VWindow(screen), 2 * screen->border + screen->scrollbar,
  1679.      2 * screen->border + Titlebar(screen) + screen->statusheight,
  1680.      fInfo->width, fInfo->height);
  1681.  
  1682.     screen->cur_col = screen->cur_row = 0;
  1683.     screen->max_col = Width(screen)  / fInfo->width - 1;
  1684.     screen->top_marg = 0;
  1685.     screen->bot_marg = screen->max_row = Height(screen) / fInfo->height - 1;
  1686.  
  1687.     screen->sc.row = screen->sc.col = screen->sc.flags = NULL;
  1688.  
  1689.     SetIconSize( screen );        /* requires max_col, max_row */
  1690.  
  1691.     /* allocate memory for screen buffer (including one for status line */
  1692.     screen->buf = screen->allbuf = (ScrnBuf) Allocate (screen->max_row + 2,
  1693.                       screen->max_col +1);
  1694.  
  1695.     screen->do_wrap = NULL;
  1696.     screen->scrolls = screen->incopy = 0;
  1697.     free((char *)fInfo);
  1698.     vp = &VTbox[1];
  1699.     (vp++)->x = FontWidth(screen) - 1;
  1700.     (vp++)->y = FontHeight(screen) - 1;
  1701.     (vp++)->x = -(FontWidth(screen) - 1);
  1702.     vp->y = -(FontHeight(screen) - 1);
  1703.     screen->box = VTbox;
  1704.     status_box[0].x = screen->border - 1;
  1705.     screen->savelines = save_lines;
  1706.     if(screen->scrollbar) {
  1707.         screen->scrollbar = 0;
  1708.         ScrollBarOn(screen, TRUE, TRUE);
  1709.         screen->sb->action = NONE;
  1710.     }
  1711.     screen->nmarginbell = n_marginbell;
  1712.     if(Titlebar(screen))
  1713.         VTTitleShow(TRUE);
  1714.     return(TRUE);
  1715. }
  1716.  
  1717. VTExpose(rep)
  1718. register XExposeWindowEvent *rep;
  1719. {
  1720.     register Screen *screen = &term.screen;
  1721.  
  1722.     if (rep && ScreenResize (screen, rep->width, rep->height, &term.flags)
  1723.      == -1)
  1724.         return;
  1725.     XClear (VWindow(screen));
  1726.     ScrnRefresh(screen, 0, 0, screen->max_row + 1 + screen->statusline,
  1727.      screen->max_col + 1);
  1728. }
  1729.  
  1730. /*
  1731.  * Shows cursor at new cursor position in screen.
  1732.  */
  1733. ShowCursor()
  1734. {
  1735.     register Screen *screen = &term.screen;
  1736.     register int fg;
  1737.     register int bg;
  1738.     register int x, y, flags;
  1739.     register Font fnt;
  1740.     char c;
  1741.  
  1742.     if (screen->icon_show && !screen->active_icon) return;
  1743.  
  1744.     if(!screen->instatus && screen->cur_row - screen->topline >
  1745.      screen->max_row)
  1746.         return;
  1747.     c = screen->buf[y = 2 * (screen->cursor_row = screen->cur_row)]
  1748.      [x = screen->cursor_col = screen->cur_col];
  1749.     flags = screen->buf[y + 1][x];
  1750.     if (c == 0)
  1751.         c = ' ';
  1752.     if(screen->instatus)
  1753.         flags ^= INVERSE;
  1754.     if(screen->select) {
  1755.         if(flags & INVERSE) {
  1756.             if(screen->cursorcolor != screen->foreground) {
  1757.                 fg = screen->foreground;
  1758.                 bg = screen->cursorcolor;
  1759.             } else {
  1760.                 fg = screen->foreground;
  1761.                 bg = screen->background;
  1762.             }
  1763.         } else {
  1764.             fg = screen->background;
  1765.             bg = screen->cursorcolor;
  1766.         }
  1767.     } else {
  1768.         if(flags & INVERSE) {
  1769.             fg = screen->background;
  1770.             bg = screen->foreground;
  1771.         } else {
  1772.             fg = screen->foreground;
  1773.             bg = screen->background;
  1774.         }
  1775.     }
  1776.     fnt = ActiveIcon(screen) ? screen->fnt_icon
  1777.           : (flags & BOLD) ? screen->fnt_bold : screen->fnt_norm;
  1778.     XText(VWindow(screen), x = CursorX (screen, screen->cur_col),
  1779.      y = CursorY(screen, screen->cur_row), &c, 1, fnt, fg, bg);
  1780.     if((flags & BOLD) && screen->enbolden)
  1781.         XTextMask(VWindow(screen), x + 1, y, &c, 1, fnt, fg);
  1782.     if(flags & UNDERLINE) {
  1783.         bg = y + FontHeight(screen) - 2;
  1784.         XLine(VWindow(screen), x, bg, x + FontWidth(screen), bg,
  1785.          1, 1, fg, GXcopy, AllPlanes);
  1786.     }
  1787.     if(!screen->select && !ActiveIcon(screen)) {
  1788.         screen->box->x = x;
  1789.         screen->box->y = y;
  1790.         XDraw(VWindow(screen), screen->box, NBOX, 1, 1, fg, GXcopy,
  1791.          AllPlanes);
  1792.     }
  1793.     screen->cursor_state = ON;
  1794. }
  1795.  
  1796. /*
  1797.  * hide cursor at previous cursor position in screen.
  1798.  */
  1799. HideCursor()
  1800. {
  1801.     register Screen *screen = &term.screen;
  1802.     register int fg;
  1803.     register int bg;
  1804.     register int x, y, flags, instatus;
  1805.     register Font fnt;
  1806.     char c;
  1807.  
  1808.     if (screen->icon_show && !screen->active_icon) return;
  1809.  
  1810.     if(!(instatus = screen->cursor_row > screen->max_row) &&
  1811.      screen->cursor_row - screen->topline > screen->max_row)
  1812.         return;
  1813.     c = screen->buf[y = 2 * screen->cursor_row][x = screen->cursor_col];
  1814.     flags = screen->buf[y + 1][x];
  1815.     if(instatus)
  1816.         flags ^= INVERSE;
  1817.     if(flags & INVERSE) {
  1818.         fg = screen->background;
  1819.         bg = screen->foreground;
  1820.     } else {
  1821.         fg = screen->foreground;
  1822.         bg = screen->background;
  1823.     }
  1824.     if (c == 0)
  1825.         c = ' ';
  1826.     y = (instatus ? (screen->cursor_row * FontHeight(screen) + 1) :
  1827.      ((screen->cursor_row - screen->topline) * FontHeight(screen))) +
  1828.      Titlebar(screen) + screen->border;
  1829.     fnt = ActiveIcon(screen) ? screen->fnt_icon
  1830.           : (flags & BOLD) ? screen->fnt_bold : screen->fnt_norm;
  1831.     XText(VWindow(screen), x = CursorX (screen, screen->cursor_col),
  1832.      y, &c, 1, fnt, fg, bg);
  1833.     if((flags & BOLD) && screen->enbolden)
  1834.         XTextMask(VWindow(screen), x + 1, y, &c, 1, fnt, fg);
  1835.     if(flags & UNDERLINE) {
  1836.         y += FontHeight(screen) - 2;
  1837.         XLine(VWindow(screen), x, y, x + FontWidth(screen), y,
  1838.          1, 1, fg, GXcopy, AllPlanes);
  1839.     }
  1840.     screen->cursor_state = OFF;
  1841. }
  1842.  
  1843. VTSelect()
  1844. {
  1845.     register Screen *screen = &term.screen;
  1846.  
  1847.     if(screen->borderwidth > 0)
  1848.         XChangeBorder(VWindow(screen), screen->bordertile);
  1849.     if(Titlebar(screen))
  1850.         VTTitleHilite();
  1851. }
  1852.  
  1853. VTUnselect()
  1854. {
  1855.     register Screen *screen = &term.screen;
  1856.  
  1857.     if(screen->borderwidth > 0)
  1858.         XChangeBorder(VWindow(screen), screen->graybordertile);
  1859.     if(Titlebar(screen))
  1860.         VTTitleUnhilite();
  1861. }
  1862.  
  1863. VTReset(full)
  1864. int full;
  1865. {
  1866.     register Screen *screen = &term.screen;
  1867.  
  1868.     /* reset scrolling region */
  1869.     screen->top_marg = 0;
  1870.     screen->bot_marg = screen->max_row;
  1871.     term.flags &= ~ORIGIN;
  1872.     if(full) {
  1873.         TabReset (term.tabs);
  1874.         term.keyboard.flags = NULL;
  1875.         screen->gsets[0] = 'B';
  1876.         screen->gsets[1] = 'B';
  1877.         screen->gsets[2] = 'B';
  1878.         screen->gsets[3] = 'B';
  1879.         screen->curgl = 0;
  1880.         screen->curgr = 2;
  1881.         screen->curss = 0;
  1882.         ClearScreen(screen);
  1883.         screen->cursor_state = OFF;
  1884.         if(!(term.flags & AUTOREPEAT))
  1885.             XAutoRepeatOn();
  1886.         if (term.flags & REVERSE_VIDEO)
  1887.             ReverseVideo(&term);
  1888.  
  1889.         term.flags = term.initflags;
  1890.         if(screen->c132 && (term.flags & IN132COLUMNS)) {
  1891.             XChangeWindow (VWindow(screen), 80 * FontWidth(screen) +
  1892.              2 * screen->border + screen->scrollbar,
  1893.              FontHeight(screen) * (screen->max_row + 1) +
  1894.              screen->statusheight + Titlebar(screen) +
  1895.              2 * screen->border);
  1896.             XSync(FALSE);    /* synchronize */
  1897.             if(QLength() > 0)
  1898.                 xevents();
  1899.         }
  1900.         CursorSet(screen, 0, 0, term.flags);
  1901.     }
  1902.     longjmp(vtjmpbuf, 1);    /* force ground state in parser */
  1903. }
  1904.  
  1905. ToStatus(col)
  1906. int col;
  1907. {
  1908.     register Screen *screen = &term.screen;
  1909.  
  1910.     if(col > screen->max_col)
  1911.         col = screen->max_col;
  1912.     if(!screen->instatus) {
  1913.         if(!screen->statusline)
  1914.             ShowStatus();
  1915.         CursorSave(&term, &screen->statussc);
  1916.         screen->instatus = TRUE;
  1917.         screen->cur_row = screen->max_row + 1;
  1918.     }
  1919.     screen->cur_col = col;
  1920. }
  1921.  
  1922. FromStatus()
  1923. {
  1924.     register Screen *screen = &term.screen;
  1925.  
  1926.     if(!screen->instatus)
  1927.         return;
  1928.     screen->instatus = FALSE;
  1929.     CursorRestore(&term, &screen->statussc);
  1930. }
  1931.  
  1932. ShowStatus()
  1933. {
  1934.     register Screen *screen = &term.screen;
  1935.     register int border = 2 * screen->border;
  1936.  
  1937.     if(screen->statusline)
  1938.         return;
  1939.     screen->statusline = 1;
  1940.     screen->statusheight = FontHeight(screen) + 2;
  1941.     XSetResizeHint(VWindow(screen), border + screen->scrollbar, border +
  1942.      Titlebar(screen) + screen->statusheight, FontWidth(screen),
  1943.      FontHeight(screen));
  1944.     XChangeWindow (VWindow(screen), FontWidth(screen) * (screen->max_col + 1)
  1945.      + border + screen->scrollbar, FontHeight(screen) *
  1946.      (screen->max_row + 1) + screen->statusheight + Titlebar(screen) +
  1947.      border);
  1948. }
  1949.  
  1950. HideStatus()
  1951. {
  1952.     register Screen *screen = &term.screen;
  1953.     register int border = 2 * screen->border;
  1954.     register int i, j;
  1955.  
  1956.     if(!screen->statusline)
  1957.         return;
  1958.     if(screen->instatus)
  1959.         FromStatus();
  1960.     screen->statusline = 0;
  1961.     screen->statusheight = 0;
  1962.     bzero(screen->buf[i = 2 * (screen->max_row + 1)], j = screen->max_col +
  1963.      1);
  1964.     bzero(screen->buf[i + 1], j);
  1965.     XSetResizeHint(VWindow(screen), border + screen->scrollbar, border +
  1966.      Titlebar(screen), FontWidth(screen), FontHeight(screen));
  1967.     XChangeWindow (VWindow(screen), FontWidth(screen) * j + border +
  1968.      screen->scrollbar, FontHeight(screen) * (screen->max_row + 1) +
  1969.      border + Titlebar(screen));
  1970. }
  1971.  
  1972. EraseStatus()
  1973. {
  1974.     register Screen *screen = &term.screen;
  1975.     register int i, j, pix;
  1976.  
  1977.     if(!screen->statusline)
  1978.         return;
  1979.     bzero(screen->buf[i = 2 * (screen->max_row + 1)], j = screen->max_col +
  1980.      1);
  1981.     bzero(screen->buf[i + 1], j);
  1982.     XPixSet(VWindow(screen), screen->border - 1, (screen->max_row + 1) *
  1983.      FontHeight(screen) + screen->border + Titlebar(screen), j *
  1984.      FontWidth(screen) + 2, screen->statusheight, screen->reversestatus ?
  1985.      screen->foreground : screen->background);
  1986.     if(!screen->reversestatus)
  1987.         StatusBox(screen);
  1988. }
  1989.  
  1990. StatusBox(screen)
  1991. register Screen *screen;
  1992. {
  1993.     status_box[0].y = (screen->max_row + 1) * FontHeight(screen) +
  1994.      screen->border + Titlebar(screen);
  1995.     status_box[3].x = -(status_box[1].x = (screen->max_col + 1) *
  1996.      FontWidth(screen) + 1);
  1997.     status_box[4].y = -(status_box[2].y = FontHeight(screen) + 1);
  1998.     XDraw(VWindow(screen), status_box, NBOX, 1, 1, screen->foreground,
  1999.      GXcopy, AllPlanes);
  2000. }
  2001.  
  2002. VTTitleShow(init)
  2003. int init;
  2004. {
  2005.     register Screen *screen = &term.screen;
  2006.     register int border = 2 * screen->border;
  2007.  
  2008.     if(!screen->title.tbar)
  2009.         VTTitleInit();
  2010.     if(!init) {
  2011.         XSetResizeHint(VWindow(screen), border + screen->scrollbar,
  2012.          border + Titlebar(screen) + screen->statusheight,
  2013.          FontWidth(screen), FontHeight(screen));
  2014.         XChangeWindow (VWindow(screen), FontWidth(screen) *
  2015.          (screen->max_col + 1) + border + screen->scrollbar,
  2016.          FontHeight(screen) * (screen->max_row + 1) + screen->statusheight
  2017.          + Titlebar(screen) + border);
  2018.     }
  2019.     if(screen->select && !screen->TekEmu)
  2020.         VTTitleHilite();
  2021.     else
  2022.         VTTitleUnhilite();
  2023.     XMapWindow(screen->title.tbar);
  2024. }
  2025.  
  2026. VTTitleHide()
  2027. {
  2028.     register Screen *screen = &term.screen;
  2029.     register int border = 2 * screen->border;
  2030.  
  2031.     XUnmapWindow(screen->title.tbar);
  2032.     XSetResizeHint(VWindow(screen), border + screen->scrollbar, border +
  2033.      screen->statusheight, FontWidth(screen), FontHeight(screen));
  2034.     XChangeWindow (VWindow(screen), FontWidth(screen) * (screen->max_col + 1)
  2035.      + border + screen->scrollbar, FontHeight(screen) *
  2036.      (screen->max_row + 1) + screen->statusheight + border);
  2037. }
  2038.  
  2039. VTTitleHilite()
  2040. {
  2041.     register Screen *screen = &term.screen;
  2042.  
  2043.     if(screen->title.hilited)
  2044.         return;
  2045.     XMapWindow(screen->title.left);
  2046.     XMapWindow(screen->title.right);
  2047.     screen->title.hilited = TRUE;
  2048. }
  2049.  
  2050. VTTitleUnhilite()
  2051. {
  2052.     register Screen *screen = &term.screen;
  2053.  
  2054.     if(!screen->title.hilited)
  2055.         return;
  2056.     XUnmapWindow(screen->title.left);
  2057.     XUnmapWindow(screen->title.right);
  2058.     screen->title.hilited = FALSE;
  2059. }
  2060.  
  2061. VTTitleResize(width)
  2062. register int width;
  2063. {
  2064.     register Screen *screen = &term.screen;
  2065.     register int i, j;
  2066.  
  2067.     if((screen->title.width = i = screen->title.fullwidth) >
  2068.      (j = width - 2 * (MINHILITE + screen->title_n_size + 1)))
  2069.         screen->title.width = (i = j) + screen->title_n_size;
  2070.     j = width - i - 2 * (screen->title_n_size + 1);
  2071.     i = j / 2;
  2072.     j -= i;
  2073.     screen->title.x = i + 1 + screen->title_n_size;
  2074.     XChangeWindow(screen->title.tbar, width, screen->titleheight - 1);
  2075.     XChangeWindow(screen->title.left, i, screen->titlefont->height);
  2076.     XConfigureWindow(screen->title.right, width - j - 1, TITLEPAD, j,
  2077.      screen->titlefont->height);
  2078. }
  2079.  
  2080. VTTitleExpose(rep)
  2081. register XExposeWindowEvent *rep;
  2082. {
  2083.     register Screen *screen = &term.screen;
  2084.  
  2085.     if(rep && (rep->x > (screen->title.x + screen->title.width) ||
  2086.      (rep->x + rep->width) < screen->title.x ||
  2087.      rep->y > (screen->title.y + screen->titlefont->height) ||
  2088.      (rep->y + rep->height) < screen->title.y))
  2089.         return;
  2090.     XText(screen->title.tbar, screen->title.x, screen->title.y,
  2091.      screen->winname, screen->winnamelen, screen->titlefont->id,
  2092.      screen->foreground, screen->background);
  2093. }
  2094.  
  2095. VTTitleInit()
  2096. {
  2097.     register Screen *screen = &term.screen;
  2098.     register int w, i, j;
  2099.     OpaqueFrame hilite[2];
  2100.     extern Pixmap make_hilite();
  2101.  
  2102.     if((screen->title.tbar = XCreateWindow(VWindow(screen), -1, -1,
  2103.      w = FullWidth(screen), screen->titleheight - 1, 1, screen->bordertile,
  2104.      screen->bgndtile)) == NULL)
  2105.         Error(ERROR_CRTITLE);
  2106.     XSelectInput(screen->title.tbar, ButtonPressed | ButtonReleased |
  2107.      ExposeWindow | EnterWindow | LeaveWindow | UnmapWindow);
  2108.     XDefineCursor(screen->title.tbar, screen->arrow);
  2109.     if(!screen->hilitetile && (screen->hilitetile =
  2110.      make_hilite(screen->foreground, screen->background)) == NULL)
  2111.         Error(ERROR_HILITE);
  2112.     screen->title.fullwidth = XQueryWidth(screen->winname,
  2113.      screen->titlefont->id);
  2114.     if((screen->title.width = i = screen->title.fullwidth) >
  2115.      (j = w - 2 * (MINHILITE + screen->title_n_size + 1)))
  2116.         screen->title.width = (i = j) + screen->title_n_size;
  2117.     j = w - i - 2 * (screen->title_n_size + 1);
  2118.     i = j / 2;
  2119.     j -= i;
  2120.     screen->title.x = i + 1 + screen->title_n_size;
  2121.     screen->title.y = TITLEPAD;
  2122.     hilite[0].x = 1;
  2123.     hilite[1].x = w - j - 1;
  2124.     hilite[0].y = hilite[1].y = TITLEPAD;
  2125.     hilite[0].width = i;
  2126.     hilite[1].width = j;
  2127.     hilite[0].height = hilite[1].height = screen->titlefont->height;
  2128.     hilite[0].bdrwidth = hilite[1].bdrwidth = 0;
  2129.     hilite[0].border = hilite[1].border = NULL;
  2130.     hilite[0].background = hilite[1].background = screen->hilitetile;
  2131.     if(XCreateWindows(screen->title.tbar, hilite, 2) != 2)
  2132.         Error(ERROR_CRLFRG);
  2133.     screen->title.left = hilite[0].self;
  2134.     screen->title.right = hilite[1].self;
  2135. }
  2136.  
  2137. #ifdef MODEMENU
  2138. #define    MMENU_SCROLL    0
  2139. #define    MMENU_VIDEO    (MMENU_SCROLL+1)
  2140. #define    MMENU_WRAP    (MMENU_VIDEO+1)
  2141. #define    MMENU_REVERSEWRAP (MMENU_WRAP+1)
  2142. #define    MMENU_NLM    (MMENU_REVERSEWRAP+1)
  2143. #define    MMENU_CURSOR    (MMENU_NLM+1)
  2144. #define    MMENU_PAD    (MMENU_CURSOR+1)
  2145. #define    MMENU_REPEAT    (MMENU_PAD+1)
  2146. #define    MMENU_SCROLLBAR    (MMENU_REPEAT+1)
  2147. #define    MMENU_PAGEMODE    (MMENU_SCROLLBAR+1)
  2148. #define    MMENU_STATUS    (MMENU_PAGEMODE+1)
  2149. #define    MMENU_REVSTATUS    (MMENU_STATUS+1)
  2150. #define    MMENU_C132    (MMENU_REVSTATUS+1)
  2151. #define    MMENU_CURSES    (MMENU_C132+1)
  2152. #define    MMENU_MARGBELL    (MMENU_CURSES+1)
  2153. #define    MMENU_TEKWIN    (MMENU_MARGBELL+1)
  2154. #define    MMENU_ALTERN    (MMENU_TEKWIN+1)
  2155. #define    MMENU_LINE    (MMENU_ALTERN+1)
  2156. #define    MMENU_RESET    (MMENU_LINE+1)
  2157. #define    MMENU_FULLRESET    (MMENU_RESET+1)
  2158. #define    MMENU_TEKMODE    (MMENU_FULLRESET+1)
  2159. #define    MMENU_HIDEVT    (MMENU_TEKMODE+1)
  2160.  
  2161. static char *vtext[] = {
  2162.     "Jump Scroll",
  2163.     "Reverse Video",
  2164.     "Auto Wraparound",
  2165.     "Reverse Wraparound",
  2166.     "Auto Linefeed",
  2167.     "Application Cursors",
  2168.     "Application Pad",
  2169.     "Auto Repeat",
  2170.     "Scrollbar",
  2171.     "Page Scroll",
  2172.     "Status Line",
  2173.     "Reverse Status Line",
  2174.     "80 <-> 132 Columns",
  2175.     "Curses Emulation",
  2176.     "Margin Bell",
  2177.     "Tek Window Showing",
  2178.     "Alternate Screen",
  2179.     "-",
  2180.     "Soft Reset",
  2181.     "Full Reset",
  2182.     "Select Tek Mode",
  2183.     "Hide VT Window",
  2184.     0,
  2185. };
  2186.  
  2187.  
  2188. static int menutermflags;
  2189. static int menukbdflags;
  2190. static int t132;
  2191. static int taltern;
  2192. static int tcurses;
  2193. static int tmarginbell;
  2194. static int tpagemode;
  2195. static int trevstatus;
  2196. static int tscrollbar;
  2197. static int tshow;
  2198. static int tstatusline;
  2199.  
  2200. Menu *setupmenu(menu)
  2201. register Menu **menu;
  2202. {
  2203.     register Screen *screen = &term.screen;
  2204.     register char **cp;
  2205.     register int flags = term.flags;
  2206.     register int kflags = term.keyboard.flags;
  2207.  
  2208.     if (*menu == NULL) {
  2209.         if ((*menu = NewMenu("Modes", re_verse)) == NULL)
  2210.             return(NULL);
  2211.         for(cp = vtext ; *cp ; cp++)
  2212.             AddMenuItem(*menu, *cp);
  2213.         if(!(flags & SMOOTHSCROLL))
  2214.             CheckItem(*menu, MMENU_SCROLL);
  2215.         if(flags & REVERSE_VIDEO)
  2216.             CheckItem(*menu, MMENU_VIDEO);
  2217.         if(flags & WRAPAROUND)
  2218.             CheckItem(*menu, MMENU_WRAP);
  2219.         if(flags & REVERSEWRAP)
  2220.             CheckItem(*menu, MMENU_REVERSEWRAP);
  2221.         if(flags & LINEFEED)
  2222.             CheckItem(*menu, MMENU_NLM);
  2223.         if(kflags & CURSOR_APL)
  2224.             CheckItem(*menu, MMENU_CURSOR);
  2225.         if(kflags & KYPD_APL)
  2226.             CheckItem(*menu, MMENU_PAD);
  2227.         if(flags & AUTOREPEAT)
  2228.             CheckItem(*menu, MMENU_REPEAT);
  2229.         if(tscrollbar = (screen->scrollbar > 0))
  2230.             CheckItem(*menu, MMENU_SCROLLBAR);
  2231.         if(tpagemode = screen->pagemode)
  2232.             CheckItem(*menu, MMENU_PAGEMODE);
  2233.         if(tstatusline = screen->statusline)
  2234.             CheckItem(*menu, MMENU_STATUS);
  2235.         if(trevstatus = screen->reversestatus)
  2236.             CheckItem(*menu, MMENU_REVSTATUS);
  2237.         if(t132 = screen->c132)
  2238.             CheckItem(*menu, MMENU_C132);
  2239.         if(tcurses = screen->curses)
  2240.             CheckItem(*menu, MMENU_CURSES);
  2241.         if(tmarginbell = screen->marginbell)
  2242.             CheckItem(*menu, MMENU_MARGBELL);
  2243.         if(tshow = screen->Tshow)
  2244.             CheckItem(*menu, MMENU_TEKWIN);
  2245.         else
  2246.             DisableItem(*menu, MMENU_HIDEVT);
  2247.         DisableItem(*menu, MMENU_ALTERN);
  2248.         if(taltern = screen->alternate) {
  2249.             CheckItem(*menu, MMENU_ALTERN);
  2250.             DisableItem(*menu, MMENU_PAGEMODE);
  2251.         }
  2252.         DisableItem(*menu, MMENU_LINE);
  2253.         if(screen->inhibit & I_TEK) {
  2254.             DisableItem(*menu, MMENU_TEKWIN);
  2255.             DisableItem(*menu, MMENU_TEKMODE);
  2256.         }
  2257.         menutermflags = flags;
  2258.         menukbdflags = kflags;
  2259.         return(*menu);
  2260.     }
  2261.     if ((menutermflags ^= flags) & SMOOTHSCROLL)
  2262.         SetItemCheck(*menu, MMENU_SCROLL, !(flags & SMOOTHSCROLL));
  2263.     if (menutermflags & REVERSE_VIDEO)
  2264.         SetItemCheck(*menu, MMENU_VIDEO, flags & REVERSE_VIDEO);
  2265.     if (menutermflags & WRAPAROUND)
  2266.         SetItemCheck(*menu, MMENU_WRAP, flags & WRAPAROUND);
  2267.     if (menutermflags & REVERSEWRAP)
  2268.         SetItemCheck(*menu, MMENU_REVERSEWRAP, flags & REVERSEWRAP);
  2269.     if (menutermflags & LINEFEED)
  2270.         SetItemCheck(*menu, MMENU_NLM, flags & LINEFEED);
  2271.     if ((menukbdflags ^= kflags) & CURSOR_APL)
  2272.         SetItemCheck(*menu, MMENU_CURSOR, kflags & CURSOR_APL);
  2273.     if (menukbdflags & KYPD_APL)
  2274.         SetItemCheck(*menu, MMENU_PAD, NULL, kflags & KYPD_APL);
  2275.     if(tscrollbar != (screen->scrollbar > 0))
  2276.         SetItemCheck(*menu, MMENU_SCROLLBAR, (tscrollbar =
  2277.          (screen->scrollbar > 0)));
  2278.     if(tpagemode != screen->pagemode)
  2279.         SetItemCheck(*menu, MMENU_PAGEMODE, (tpagemode =
  2280.          screen->pagemode));
  2281.     if(tstatusline != screen->statusline)
  2282.         SetItemCheck(*menu, MMENU_STATUS, (tstatusline =
  2283.          screen->statusline));
  2284.     if(trevstatus != screen->reversestatus)
  2285.         SetItemCheck(*menu, MMENU_REVSTATUS, (trevstatus =
  2286.          screen->reversestatus));
  2287.     if(t132 != screen->c132)
  2288.         SetItemCheck(*menu, MMENU_C132, (t132 = screen->c132));
  2289.     if(tcurses != screen->curses)
  2290.         SetItemCheck(*menu, MMENU_CURSES, (tcurses = screen->curses));
  2291.     if(tmarginbell != screen->marginbell)
  2292.         SetItemCheck(*menu, MMENU_MARGBELL, (tmarginbell =
  2293.         screen->marginbell));
  2294.     if(tshow != screen->Tshow) {
  2295.         SetItemCheck(*menu, MMENU_TEKWIN, (tshow = screen->Tshow));
  2296.         SetItemDisable(*menu, MMENU_HIDEVT, !tshow);
  2297.     }
  2298.     if(taltern != screen->alternate) {
  2299.         SetItemCheck(*menu, MMENU_ALTERN, (taltern =
  2300.          screen->alternate));
  2301.         SetItemDisable(*menu, MMENU_PAGEMODE, taltern);
  2302.     }
  2303.     menutermflags = flags;
  2304.     menukbdflags = kflags;
  2305.     return(*menu);
  2306. }
  2307.  
  2308. domenufunc(item)
  2309. int item;
  2310. {
  2311.     register Screen *screen = &term.screen;
  2312.  
  2313.     switch (item) {
  2314.     case MMENU_SCROLL:
  2315.         term.flags ^= SMOOTHSCROLL;
  2316.         if (term.flags & SMOOTHSCROLL) {
  2317.             screen->jumpscroll = FALSE;
  2318.             if (screen->scroll_amt)
  2319.                 FlushScroll(screen);
  2320.         } else
  2321.             screen->jumpscroll = TRUE;
  2322.         break;
  2323.  
  2324.     case MMENU_VIDEO:
  2325.         term.flags ^= REVERSE_VIDEO;
  2326.         ReverseVideo(&term);
  2327.         break;
  2328.  
  2329.     case MMENU_WRAP:
  2330.         term.flags ^= WRAPAROUND;
  2331.         break;
  2332.  
  2333.     case MMENU_REVERSEWRAP:
  2334.         term.flags ^= REVERSEWRAP;
  2335.         break;
  2336.  
  2337.     case MMENU_NLM:
  2338.         term.flags ^= LINEFEED;
  2339.         break;
  2340.  
  2341.     case MMENU_CURSOR:
  2342.         term.keyboard.flags ^= CURSOR_APL;
  2343.         break;
  2344.  
  2345.     case MMENU_PAD:
  2346.         term.keyboard.flags ^= KYPD_APL;
  2347.         break;
  2348.  
  2349.     case MMENU_REPEAT:
  2350.         term.flags ^= AUTOREPEAT;
  2351.         if (term.flags & AUTOREPEAT)
  2352.             XAutoRepeatOn();
  2353.         else
  2354.             XAutoRepeatOff();
  2355.         break;
  2356.  
  2357.     case MMENU_SCROLLBAR:
  2358.         if(screen->scrollbar)
  2359.             ScrollBarOff(screen);
  2360.         else
  2361.             ScrollBarOn(screen, TRUE, FALSE);
  2362.         break;
  2363.  
  2364.     case MMENU_PAGEMODE:
  2365.         if(screen->pagemode = !screen->pagemode)
  2366.             screen->pagecnt = 0;
  2367.         break;
  2368.  
  2369.     case MMENU_STATUS:
  2370.         if(screen->statusline)
  2371.             HideStatus();
  2372.         else
  2373.             ShowStatus();
  2374.         break;
  2375.  
  2376.     case MMENU_REVSTATUS:
  2377.         screen->reversestatus = !screen->reversestatus;
  2378.         ScrnRefresh(screen, screen->max_row + 1, 0, 1, screen->max_col
  2379.          + 1);
  2380.         break;
  2381.  
  2382.     case MMENU_C132:
  2383.         screen->c132 = !screen->c132;
  2384.         break;
  2385.  
  2386.     case MMENU_MARGBELL:
  2387.         if(!(screen->marginbell = !screen->marginbell))
  2388.             screen->bellarmed = -1;
  2389.         break;
  2390.  
  2391.     case MMENU_CURSES:
  2392.         screen->curses = !screen->curses;
  2393.         break;
  2394.  
  2395.     case MMENU_FULLRESET:
  2396.         VTReset(TRUE);
  2397.         break;
  2398.  
  2399.     case MMENU_RESET:
  2400.         VTReset(FALSE);
  2401.         break;
  2402.  
  2403.     case MMENU_HIDEVT:
  2404.         screen->show = FALSE;
  2405.         XUnmapWindow(VWindow(screen));
  2406.         reselectwindow(screen);
  2407.         SyncUnmap(VWindow(screen), WINDOWEVENTS);
  2408.             /* drop through */
  2409.     case MMENU_TEKMODE:
  2410.         if(!screen->TekEmu) {
  2411.             if(screen->logging) {
  2412.                 FlushLog(screen);
  2413.                 screen->logstart = Tbuffer;
  2414.             }
  2415.             screen->TekEmu = TRUE;
  2416.             if(screen->pagemode) {
  2417.                 Scroll(screen, screen->pagecnt);
  2418.                 screen->pagecnt = 0;
  2419.                 ioctl(screen->respond, TIOCSTART, NULL);
  2420.             }
  2421.             longjmp(VTend, 1);
  2422.         } else
  2423.             XRaiseWindow(TWindow(screen));
  2424.         break;
  2425.  
  2426.     case MMENU_TEKWIN:
  2427.         if(screen->Tshow = !screen->Tshow) {
  2428.             if(TWindow(screen) || TekInit()) {
  2429.                 XMapWindow(TWindow(screen));
  2430.                 screen->Tshow = TRUE;
  2431.             }
  2432.         } else {
  2433.             screen->Tshow = FALSE;
  2434.             XUnmapWindow(TWindow(screen));
  2435.             SyncUnmap(TWindow(screen), TWINDOWEVENTS);
  2436.             if(screen->TekEmu) {
  2437.                 if(screen->logging) {
  2438.                     FlushLog(screen);
  2439.                     screen->logstart = buffer;
  2440.                 }
  2441.                 longjmp(Tekend, 1);
  2442.             }
  2443.         }
  2444.         reselectwindow(screen);
  2445.         break;
  2446.     }
  2447. }
  2448. #endif MODEMENU
  2449. RAZZLE!DAZZLE
  2450. fi    # End charproc.c
  2451. if test -f data.c
  2452. then
  2453.     echo shar: will not overwrite existing file "'data.c'"
  2454. else
  2455. echo 'x - data.c'
  2456. cat << \RAZZLE!DAZZLE > data.c
  2457. /*
  2458.  *    $Source: /u1/X/xterm/RCS/data.c,v $
  2459.  *    $Header: data.c,v 10.102 86/12/01 17:12:39 swick Rel $
  2460.  */
  2461.  
  2462. #include <setjmp.h>
  2463. #include <X/Xlib.h>
  2464. #include "scrollbar.h"
  2465. #include "ptyx.h"
  2466.  
  2467. #ifndef lint
  2468. static char sccs_id[] = "@(#)data.c\tX10/6.6B\t12/26/86";
  2469. #endif    lint
  2470.  
  2471. Vertex T_boxlarge[NBOX] = {
  2472.     {0, 0, VertexDontDraw},
  2473.     {8, 0, VertexRelative},
  2474.     {0, 14, VertexRelative},
  2475.     {-8, 0, VertexRelative},
  2476.     {0, -14, VertexRelative},
  2477. };
  2478. Vertex T_box2[NBOX] = {
  2479.     {0, 0, VertexDontDraw},
  2480.     {7, 0, VertexRelative},
  2481.     {0, 12, VertexRelative},
  2482.     {-7, 0, VertexRelative},
  2483.     {0, -12, VertexRelative},
  2484. };
  2485. Vertex T_box3[NBOX] = {
  2486.     {0, 0, VertexDontDraw},
  2487.     {5, 0, VertexRelative},
  2488.     {0, 12, VertexRelative},
  2489.     {-5, 0, VertexRelative},
  2490.     {0, -12, VertexRelative},
  2491. };
  2492. Vertex T_boxsmall[NBOX] = {
  2493.     {0, 0, VertexDontDraw},
  2494.     {5, 0, VertexRelative},
  2495.     {0, 9, VertexRelative},
  2496.     {-5, 0, VertexRelative},
  2497.     {0, -9, VertexRelative},
  2498. };
  2499. Vertex T_boxicon[NBOX] = {        /* is filled-in in TekInit() */
  2500.     {0, 0, VertexDontDraw},
  2501.     {0, 0, VertexRelative},
  2502.     {0, 0, VertexRelative},
  2503.     {0, 0, VertexRelative},
  2504.     {0, 0, VertexRelative},
  2505. };
  2506. jmp_buf Tekend;
  2507. int Tbcnt = 0;
  2508. char *Tbuffer;
  2509. char *Tbptr;
  2510. TekLink *TekRefresh;
  2511. char *Tpushb;
  2512. char *Tpushback;
  2513. int Ttoggled = 0;
  2514. int bcnt = 0;
  2515. char buffer[BUF_SIZE];
  2516. char *bptr = buffer;
  2517. jmp_buf VTend;
  2518. Vertex VTbox[NBOX] = {
  2519.     {0, 0, VertexDontDraw},
  2520.     {0, 0, VertexRelative},
  2521.     {0, 0, VertexRelative},
  2522.     {0, 0, VertexRelative},
  2523.     {0, 0, VertexRelative},
  2524. };
  2525. Vertex status_box[NBOX] = {
  2526.     {0, 0, VertexDontDraw},
  2527.     {0, 0, VertexRelative},
  2528.     {0, 0, VertexRelative},
  2529.     {0, 0, VertexRelative},
  2530.     {0, 0, VertexRelative},
  2531. };
  2532. Vertex icon_box[NBOX] = {
  2533.     {0, 0, VertexDontDraw},
  2534.     {0, 0, VertexRelative},
  2535.     {0, 0, VertexRelative},
  2536.     {0, 0, VertexRelative},
  2537.     {0, 0, VertexRelative},
  2538. };
  2539. T_fontsize Tfontsize[TEKNUMFONTS] = {
  2540.     {9, 15},    /* large */
  2541.     {8, 13},    /* #2 */
  2542.     {6, 13},    /* #3 */
  2543.     {6, 10},    /* small */
  2544.     {0, 0},        /* icon is filled-in later */
  2545. };
  2546.  
  2547.  
  2548. #ifdef DEBUG
  2549. int debug = 0;         /* true causes error messages to be displayed */
  2550. #endif DEBUG
  2551. Terminal term;        /* master data structure for client */
  2552. char *xterm_name;    /* argv[0] */
  2553. int am_slave = 0;    /* set to 1 if running as a slave process */
  2554. char *icon_geom;
  2555. int B_Pixel;
  2556. Pixmap B_Pixmap;
  2557. int L_flag;
  2558. int max_plus1;
  2559. int n_marginbell = N_MARGINBELL;
  2560. int pty_mask;
  2561. int re_verse;
  2562. int save_lines = SAVELINES;
  2563. int Select_mask;
  2564. int W_Pixel;
  2565. Pixmap W_Pixmap;
  2566. char *win_name;
  2567. int X_mask;
  2568. char *back_color;
  2569. char *curs_color;
  2570. char *f_b;
  2571. char *f_n;
  2572. char *f_t;
  2573. char *f_i;
  2574. char *fore_color;
  2575. char *geo_metry;
  2576. char *mous_color;
  2577. char *T_geometry = 0;
  2578. char *ptydev = "/dev/ptyxx";
  2579. char *ttydev = "/dev/ttyxx";
  2580. char log_def_name[] = "XtermLog.XXXXX";
  2581. int T_lastx = -1;
  2582. int T_lasty = -1;
  2583. RAZZLE!DAZZLE
  2584. fi    # End data.c
  2585. echo '***** End of' xterm 6.6B - Part 4 of 7 '*****'
  2586. exit
  2587.  
  2588.